@euphrasiologist/lwphylo 1.1.15 → 1.2.2

package/src/radial/radialLayout.js

@@ -1,18 +0,0 @@
-import radialData from "./radialData.js"
-import getRadii from "./getRadii.js"
-import getArcs from "./getArcs.js"
-
-/**
- * Simple wrapper for radial layout:
- *  - data: per-node { angle, r, x, y, ... }
- *  - radii: per-edge radial spokes (parent.r → child.r)
- *  - arcs: per-internal-node arcs spanning its children at parent radius
- */
-export default function radialLayout(node) {
-  const data = {};
-  data.data = radialData(node);
-  data.radii = getRadii(node);
-  data.arcs = getArcs(data.data);
-  return data;
-}
-

package/src/radial/reflectAngle.js

@@ -1,10 +0,0 @@
-/**
- * Legacy shim: normalize angle to [0, 2π).
- * The new radial code does not need geometric reflections;
- * it uses circular spans and atan2.
- */
-export default function reflectAngle(rad /*, dir */) {
-  const TAU = Math.PI * 2;
-  return ((rad % TAU) + TAU) % TAU;
-}
-

package/src/rectangle/getChildVerticals.js

@@ -1,47 +0,0 @@
-import getHorizontal from "./getHorizontal.js";
-
-/**
- * Build per-child vertical segments for a rectangular tree:
- * For each non-root node (child), draw a vertical from (parent.x, child.y) to (parent.x, parent.y).
- * This yields exactly one vertical per edge (child->parent), making highlighting trivial.
- *
- * Returns an array of:
- *   {
- *     parentId: number,
- *     childId: number,
- *     x: number,         // x of the parent junction
- *     y0: number,        // min(child.y, parent.y)
- *     y1: number,        // max(child.y, parent.y)
- *   }
- */
-export default function getChildVerticals(node) {
-  const data = getHorizontal(node); // has parentId, thisId, x0,x1,y0=y1
-
-  // Build a quick index to access parent's y by id
-  const byId = new Map(data.map(d => [d.thisId, d]));
-
-  const childVerticals = [];
-
-  for (const d of data) {
-    if (d.parentId == null) continue;
-    const parent = byId.get(d.parentId);
-    if (!parent) continue;
-
-    const x = d.x0;            // child’s vertical sits at parent.x == child.x0
-    const yc = d.y0;           // child y
-    const yp = parent.y0;      // parent y
-    const y0 = Math.min(yc, yp);
-    const y1 = Math.max(yc, yp);
-
-    childVerticals.push({
-      parentId: d.parentId,
-      childId: d.thisId,
-      x,
-      y0,
-      y1
-    });
-  }
-
-  return childVerticals;
-}
-

package/src/rectangle/getHorizontal.js

@@ -1,57 +0,0 @@
-import mean from "../utils/mean.js"
-import fortify from "../utils/fortify.js"
-
-/**
- * Rectangle layout: compute per-node x0,x1 and y0=y1
- * - Tip y is assigned by input order (preserves ladderize/order)
- * - Internal node y is mean of child y's
- * - x1 accumulates branch lengths from root
- */
-
-export default function getHorizontal(node) {
-  const pd = fortify(node);
-
-  // Fast lookup from id -> pd index
-  const idIndex = new Map(pd.map((d, i) => [d.thisId, i]));
-
-  // 1) Leaf order from the INPUT TREE (respects your child order / ladderize)
-  const leafIds = [];
-  (function dfs(n) {
-    if (!n.children || n.children.length === 0) { leafIds.push(n.id); return; }
-    n.children.forEach(dfs);
-  })(node);
-
-  // Map each leaf id to a vertical slot (1..N)
-  const tipSlot = new Map(leafIds.map((id, i) => [id, i + 1]));
-
-  // 2) Set Y for tips directly from that order; internal node Y via children mean
-  (function setY(n) {
-    const i = idIndex.get(n.id);
-    if (!n.children || n.children.length === 0) {
-      const y = tipSlot.get(n.id);
-      pd[i].y0 = y; pd[i].y1 = y;
-      return y;
-    }
-    const ys = n.children.map(setY);
-    const y = mean(ys);
-    pd[i].y0 = y; pd[i].y1 = y;
-    return y;
-  })(node);
-
-  // 3) Set X by accumulating branch lengths down the tree
-  (function setX(n, xParent) {
-    const i = idIndex.get(n.id);
-    const bl = pd[i].branchLength ?? 0;
-    const x0 = xParent ?? 0;
-    const x1 = x0 + bl;
-    pd[i].x0 = x0; pd[i].x1 = x1;
-    if (n.children && n.children.length) n.children.forEach(c => setX(c, x1));
-  })(node, 0);
-
-  // Clean up: remove fields not needed downstream without triggering no-unused-vars
-  return pd.map((row) => {
-    const { y: _y, x: _x, angle: _angle, ...item } = row;
-    return item;
-  });
-}
-

package/src/rectangle/getVertical.js

@@ -1,36 +0,0 @@
-import getHorizontal from "./getHorizontal.js"
-
-export default function getVertical(node) {
-  const data = getHorizontal(node);
-
-  // Group rows by parentId (children that share a parent)
-  const byParent = new Map();
-  for (const row of data) {
-    if (row.parentId == null) continue;
-    const a = byParent.get(row.parentId);
-    if (a) a.push(row); else byParent.set(row.parentId, [row]);
-  }
-
-  const verticals = [];
-  for (const [parentId, kids] of byParent.entries()) {
-    if (!kids.length) continue;
-    // Works for binary and multifurcations:
-    const yvals = kids.map(d => d.y0);
-    const y0 = Math.min(...yvals);
-    const y1 = Math.max(...yvals);
-    // All children share the same junction x (their x0)
-    const x = kids[0].x0;
-
-    verticals.push({
-      parentId,
-      x0: x,
-      x1: x,
-      y0,
-      y1,
-      heights: y1 - y0
-    });
-  }
-
-  return verticals;
-}
-

package/src/rectangle/rectangleLayout.js

@@ -1,36 +0,0 @@
-import getHorizontal from "./getHorizontal.js"
-import getVertical from "./getVertical.js"
-import getChildVerticals from "./getChildVerticals.js"
-
-/**
- * Rectangle layout wrapper.
- * Returns:
- *  - data: per-node rows (x0,x1,y0=y1,...)
- *  - vertical_lines: single spanning vertical per parent (baseline draw)
- *  - child_vertical_lines: one vertical per edge (for highlighting)
- *  - horizontal_lines: per-edge child horizontals (x0->x1 at y), with labels & tip flags
- */
-export default function rectangleLayout(node) {
-  const data = getHorizontal(node);              // per-node
-  const vertical_lines = getVertical(node);      // parent spans
-  const child_vertical_lines = getChildVerticals(node); // per-edge verticals
-
-  // IMPORTANT: include y0 & y1, and carry isTip/labels for the renderer
-  const byId = new Map(data.map(d => [d.thisId, d]));
-  const horizontal_lines = data
-    .filter(d => d.parentId != null)
-    .map(d => ({
-      parentId: d.parentId,
-      childId: d.thisId,
-      thisId: d.thisId,
-      thisLabel: d.thisLabel,
-      isTip: d.isTip,
-      x0: d.x0,
-      x1: d.x1,
-      y0: d.y0,
-      y1: d.y0
-    }));
-
-  return { data, vertical_lines, child_vertical_lines, horizontal_lines };
-}
-

package/src/unrooted/equalAngleLayout.js

@@ -1,60 +0,0 @@
-import numTips from "../utils/numTips.js"
-
-/**
- * Equal-angle layout for unrooted trees.
- * - Precomputes ntips in O(n) to avoid repeated subtree counts
- * - Uses angles in "π units" (0..2) to match existing API
- * - Populates x,y positions from branchLength and angle
- */
-
-function annotateTipCounts(root) {
-  (function post(n) {
-    if (!n.children || n.children.length === 0) {
-      n.ntips = 1; return 1;
-    }
-    let sum = 0;
-    for (const c of n.children) sum += post(c);
-    n.ntips = sum;
-    return sum;
-  })(root);
-  return root;
-}
-
-function equalAngleLayout(node) {
-  if (node.parent === null) {
-    annotateTipCounts(node);
-    node.start = 0.;     // guarantees no arcs overlap 0
-    node.end = 2.;       // *π
-    node.angle = 0.;     // irrelevant at root
-    node.ntips = numTips(node); // safe (already computed), left for compatibility
-    node.x = 0;
-    node.y = 0;
-  }
-
-  let lastStart = node.start;
-
-  for (let i = 0; i < node.children.length; i++) {
-    const child = node.children[i];
-    const arc = (node.end - node.start) * (child.ntips / node.ntips);
-
-    child.start = lastStart;
-    child.end = lastStart + arc;
-
-    // bisect the arc in π-units
-    child.angle = child.start + (child.end - child.start) / 2.;
-    lastStart = child.end;
-
-    // map to coordinates (convert π-units to radians by multiplying by Math.PI)
-    const theta = child.angle * Math.PI;
-    const bl = (child.branchLength ?? 0);
-    child.x = node.x + bl * Math.sin(theta);
-    child.y = node.y + bl * Math.cos(theta);
-
-    equalAngleLayout(child);
-  }
-
-  return node;
-}
-
-export default equalAngleLayout
-

package/src/unrooted/unrooted.js

@@ -1,18 +0,0 @@
-import edges from "../utils/edges.js";
-import fortify from "../utils/fortify.js";
-import equalAngleLayout from "./equalAngleLayout.js";
-
-/**
- * Simple wrapper function for equalAngleLayout()
- */
-
-export default function (node) {
-  var data = {};
-  // use the Felsenstein equal angle layout algorithm
-  var eq = fortify(equalAngleLayout(node));
-  data.data = eq;
-  // make the edges dataset
-  data.edges = edges(eq);
-
-  return data;
-}

package/src/utils/edges.js

@@ -1,26 +0,0 @@
-/**
- * Convert parsed Newick tree from fortify() into data frame of edges
- * this is akin to a "phylo" object in R, where thisID and parentId
- * are the $edge slot. I think.
- */
-
-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 = [];
-
-  for (const row of rows) {
-    if (row.parentId == null) continue;
-    const parent = byId.get(row.parentId);
-    if (!parent) continue;
-
-    if (rectangular) {
-      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 {
-      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/fortify.js

@@ -1,49 +0,0 @@
-import { preorder } from "./preorder.js"
-
-/**
- * Convert parsed Newick tree from readTree() into data
- * frame.
- * this is akin to a "phylo" object in R.
- */
-
-export default function (tree, sort = true) {
-    var df = [];
-
-    for (const node of preorder(tree)) {
-        if (node.parent === null) {
-            df.push({
-                'parentId': null,
-                'parentLabel': null,
-                'thisId': node.id,
-                'thisLabel': node.label,
-                'children': node.children.map(x => x.id),
-                'branchLength': 0.,
-                'isTip': false,
-                'x': node.x,
-                'y': node.y,
-                'angle': node.angle
-            })
-        }
-        else {
-            df.push({
-                'parentId': node.parent.id,
-                'parentLabel': node.parent.label,
-                'thisId': node.id,
-                'thisLabel': node.label,
-                'children': node.children.map(x => x.id),
-                'branchLength': node.branchLength,
-                'isTip': (node.children.length == 0),
-                'x': node.x,
-                'y': node.y,
-                'angle': node.angle
-            })
-        }
-    }
-
-    if (sort) {
-        df = df.sort(function (a, b) {
-            return a.thisId - b.thisId;
-        })
-    }
-    return (df);
-}

package/src/utils/indexing.js

@@ -1,64 +0,0 @@
-/**
- * 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/mean.js

@@ -1,25 +0,0 @@
-/**
- * Iterable mean
- * Poached from https://github.com/d3/d3-array/blob/master/src/mean.js
- * (Other array means buggered up the tree)
- */
-
-export default function (values, valueof) {
-    let count = 0;
-    let sum = 0;
-    if (valueof === undefined) {
-        for (let value of values) {
-            if (value != null && (value = +value) >= value) {
-                ++count, sum += value;
-            }
-        }
-    } else {
-        let index = -1;
-        for (let value of values) {
-            if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
-                ++count, sum += value;
-            }
-        }
-    }
-    if (count) return sum / count;
-}

package/src/utils/meanAngle.js

@@ -1,20 +0,0 @@
-/*
-* It's on my TODO list to split all branches in half
-* so they can be highlighted separately later in the plot.
-* Find the mid point of two angles in radians
-* there are some subtleties I don't fully understand
-* 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);
-
-  // 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));
-}
-

package/src/utils/numTips.js

@@ -1,27 +0,0 @@
-/**
- * Recursive function for breadth-first search of a tree
- * the root node is visited first.
- */
-
-function levelorder(root) {
-  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);
-}

package/src/utils/parentFisheye.js

@@ -1,9 +0,0 @@
-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,38 +0,0 @@
-/**
- * Recursive function for pre-order traversal of tree (returns array)
- */
-export function preorder(node, 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]);
-    }
-  }
-}
-

package/src/utils/readTree.js

@@ -1,64 +0,0 @@
-/**
- * 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 readTree(text) {
-  // Remove all whitespace (space, tabs, newlines)
-  text = String(text).replace(/\s+/g, '');
-
-  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 === '(') {
-      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
-    }
-  }
-
-  // Ensure root has an id if not assigned during parsing
-  if (root.id == null) root.id = nodeId;
-
-  return root;
-}
-

package/src/utils/subTree.js

@@ -1,44 +0,0 @@
-/** 
-* Subset a tree given a node - i.e. the node of interests and all the descendents
-*/
-
-export default function (tree, node) {
-    // Thanks Richard Challis!
-    let fullTree = {};
-    tree.data.forEach(obj => {
-        fullTree[obj.thisId] = { ...obj };
-    });
-
-    let subTree = {};
-    const getDescendants = function (rootNodeId) {
-        if (fullTree[rootNodeId]) {
-            subTree[rootNodeId] = fullTree[rootNodeId];
-            if (fullTree[rootNodeId].children) {
-                fullTree[rootNodeId].children.forEach(childNodeId => {
-                    getDescendants(childNodeId);
-                });
-            }
-        }
-    };
-    // call the recursive function
-    getDescendants(node);
-
-    // in each of the functions, data contains the children key
-    const data = [["data", Object.values(subTree)]];
-
-    const nodes = data[0][1].map(d => d.thisId);
-
-    var res = [];
-    // in all keys except data, push to new array
-    for (const node in tree) {
-        if (node === "data") continue;
-        res.push([node, tree[node]]);
-    }
-
-    var filtered = res.map(d => [
-        d[0],
-        d[1].filter(d => nodes.includes(d.thisId))
-    ]);
-
-    return Object.fromEntries(data.concat(filtered));
-}