@euphrasiologist/lwphylo 1.1.7 → 1.1.9

package/dist/index.js

@@ -0,0 +1,2 @@
+const n={circular:()=>{let n=200,t=2,e=[0,0],r={},i=0,c=0,a=n*n,s=10;function o(){const e=Math.exp(t);return i=e/(e-1)*n,c=t/n,a=n*n,h}function h(n){!function(){if(!r||"function"!=typeof r.xscale||"function"!=typeof r.yscale)throw new Error("phisheye.circular: call .scales(xscale, yscale) before using the fisheye.")}();const t=r.xscale(n.x),o=r.yscale(n.y),h=t-e[0],l=o-e[1],u=h*h+l*l;if(0===u||u>=a)return{x:t,y:o,z:u>=a?1:s};const d=Math.sqrt(u),f=i*(1-Math.exp(-d*c))/d*.75+.25;return{x:e[0]+h*f,y:e[1]+l*f,z:Math.min(f,s)}}return h.radius=function(t){return arguments.length?(n=Math.max(0,+t),o()):n},h.distortion=function(n){return arguments.length?(t=Math.max(0,+n),o()):t},h.focus=function(n){if(!arguments.length)return e.slice();if(!Array.isArray(n)||2!==n.length)throw new Error("focus expects [x, y] in pixels.");return e=[+n[0],+n[1]],h},h.scales=function(n,t){return arguments.length?(r={xscale:n,yscale:t},h):r},h.setScales=h.scales,h.clampZ=function(n){return arguments.length?(s=Math.max(1,+n),h):s},h.focusFromEvent=function(n,t){const e=t.getBoundingClientRect(),r=n.clientX-e.left,i=n.clientY-e.top;return h.focus([r,i])},o()}};function t(n,t,e,r){return{x:n+e*Math.cos(r),y:t+e*Math.sin(r)}}function e(n){const t=n%(2*Math.PI);return t<0?t+2*Math.PI:t}function r(n,r,i,c,a){let s=e(c),o=e(a)-s;o<=-Math.PI?o+=2*Math.PI:o>Math.PI&&(o-=2*Math.PI);const h=Math.abs(o)>Math.PI?1:0,l=o>=0?1:0,u=t(n,r,i,s),d=t(n,r,i,s+o);return["M",u.x,u.y,"A",i,i,0,h,l,d.x,d.y].join(" ")}function i(n,t=[]){t.push(n);for(let e=0;e<(n.children?.length||0);e++)t=i(n.children[e],t);return t}function c(n,t=!0){var e=[];for(const t of i(n))null===t.parent?e.push({parentId:null,parentLabel:null,thisId:t.id,thisLabel:t.label,children:t.children.map(n=>n.id),branchLength:0,isTip:!1,x:t.x,y:t.y,angle:t.angle}):e.push({parentId:t.parent.id,parentLabel:t.parent.label,thisId:t.id,thisLabel:t.label,children:t.children.map(n=>n.id),branchLength:t.branchLength,isTip:0==t.children.length,x:t.x,y:t.y,angle:t.angle});return t&&(e=e.sort(function(n,t){return n.thisId-t.thisId})),e}function a(n){const t=2*Math.PI,e=c(n,!0),r=new Map(e.map(n=>[n.thisId,n])),i=new Map(e.map(n=>[n.thisId,n.children||[]]));let a=null;for(const n of e)if(null==n.parentId){a=n.thisId;break}const s=[];!function n(t){const e=i.get(t)||[];if(0!==e.length)for(const t of e)n(t);else s.push(t)}(a);const o=Math.max(1,s.length),h=new Map;s.forEach((n,e)=>{h.set(n,e/o*t)}),function n(e){const r=i.get(e)||[];for(const t of r)n(t);if(r.length>0){let n=0,i=0;for(const t of r){const e=h.get(t);n+=Math.cos(e),i+=Math.sin(e)}h.set(e,(Math.atan2(i,n)%t+t)%t)}}(a);const l=new Map;l.set(a,0),function n(t){const e=i.get(t)||[],c=l.get(t)||0;for(const t of e){const e=r.get(t),i=e?.branchLength??0;l.set(t,c+i),n(t)}}(a);for(const n of e){const t=h.get(n.thisId)??0,e=l.get(n.thisId)??0;n.angle=t,n.r=e,n.x=e*Math.cos(t),n.y=e*Math.sin(t)}return e}function s(n){const t=n%(2*Math.PI);return t<0?t+2*Math.PI:t}function o(n,t){n=s(n);let e=(t=s(t))-n;return e<=-Math.PI?e+=2*Math.PI:e>Math.PI&&(e-=2*Math.PI),[n,n+e]}function h(n){const t={};return t.data=a(n),t.radii=function(n){const t=a(n),e=new Map(t.map(n=>[n.thisId,n])),r=t.find(n=>null==n.parentId)?.thisId,i=[];for(const n of t){if(n.thisId===r)continue;const t=e.get(n.parentId);if(!t)continue;const c=n.angle,a=t.r,s=n.r;i.push({parentId:t.thisId,childId:n.thisId,x0:a*Math.cos(c),y0:a*Math.sin(c),x1:s*Math.cos(c),y1:s*Math.sin(c),isTip:!!n.isTip})}return i}(n),t.arcs=function(n){const t=new Map(n.map(n=>[n.thisId,n])),e=n.find(n=>null==n.parentId)?.thisId,r=[];for(const i of n){if(i.thisId===e)continue;const n=t.get(i.parentId);if(!n)continue;const[c,a]=o(n.angle,i.angle);isFinite(n.r)&&0!==n.r&&c!==a&&r.push({parentId:n.thisId,childId:i.thisId,radius:n.r,start:c,end:a})}return r}(t.data),t}function l(n){const t=c(n),e=new Map(t.map((n,t)=>[n.thisId,t])),r=[];!function n(t){t.children&&0!==t.children.length?t.children.forEach(n):r.push(t.id)}(n);const i=new Map(r.map((n,t)=>[n,t+1]));return function n(r){const c=e.get(r.id);if(!r.children||0===r.children.length){const n=i.get(r.id);return t[c].y0=n,t[c].y1=n,n}const a=function(n){let t=0,e=0;for(let r of n)null!=r&&(r=+r)>=r&&(++t,e+=r);if(t)return e/t}(r.children.map(n));return t[c].y0=a,t[c].y1=a,a}(n),function n(r,i){const c=e.get(r.id),a=i??0,s=a+(t[c].branchLength??0);t[c].x0=a,t[c].x1=s,r.children&&r.children.length&&r.children.forEach(t=>n(t,s))}(n,0),t.map(n=>{const{y:t,x:e,angle:r,...i}=n;return i})}function u(n){const t=l(n),e=function(n){const t=l(n),e=new Map;for(const n of t){if(null==n.parentId)continue;const t=e.get(n.parentId);t?t.push(n):e.set(n.parentId,[n])}const r=[];for(const[n,t]of e.entries()){if(!t.length)continue;const e=t.map(n=>n.y0),i=Math.min(...e),c=Math.max(...e),a=t[0].x0;r.push({parentId:n,x0:a,x1:a,y0:i,y1:c,heights:c-i})}return r}(n),r=function(n){const t=l(n),e=new Map(t.map(n=>[n.thisId,n])),r=[];for(const n of t){if(null==n.parentId)continue;const t=e.get(n.parentId);if(!t)continue;const i=n.x0,c=n.y0,a=t.y0,s=Math.min(c,a),o=Math.max(c,a);r.push({parentId:n.parentId,childId:n.thisId,x:i,y0:s,y1:o})}return r}(n),i=t.filter(n=>null!=n.parentId).map(n=>({parentId:n.parentId,childId:n.thisId,x0:n.x0,x1:n.x1,y:n.y0}));return{data:t,vertical_lines:e,child_vertical_lines:r,horizontal_lines:i}}function d(n){null===n.parent&&(function n(t){if(!t.children||0===t.children.length)return t.ntips=1,1;let e=0;for(const r of t.children)e+=n(r);return t.ntips=e,e}(n),n.start=0,n.end=2,n.angle=0,n.ntips=function(n){var t=0;for(const e of function(n){const t=[n],e=[];for(;t.length;){const n=t.shift();e.push(n);for(const e of n.children)t.push(e)}return e}(n))0==e.children.length&&t++;return t}(n),n.x=0,n.y=0);let t=n.start;for(let e=0;e<n.children.length;e++){const r=n.children[e],i=(n.end-n.start)*(r.ntips/n.ntips);r.start=t,r.end=t+i,r.angle=r.start+(r.end-r.start)/2,t=r.end;const c=r.angle*Math.PI,a=r.branchLength??0;r.x=n.x+a*Math.sin(c),r.y=n.y+a*Math.cos(c),d(r)}return n}function f(n){var t={},e=c(d(n));return t.data=e,t.edges=function(n,t=!1){const e=[...n].sort((n,t)=>n.thisId-t.thisId),r=new Map(e.map(n=>[n.thisId,n])),i=[];for(const n of e){if(null==n.parentId)continue;const e=r.get(n.parentId);e&&(t?(i.push({x1:n.x,y1:n.y,id1:n.thisId,x2:e.x,y2:n.y,id2:void 0}),i.push({x1:e.x,y1:n.y,id1:void 0,x2:e.x,y2:e.y,id2:n.parentId})):i.push({x1:n.x,y1:n.y,id1:n.thisId,x2:e.x,y2:e.y,id2:n.parentId}))}return i}(e),t}function p(n,t){const e=function(n,t="thisId"){return new Map(n.map(n=>[n[t],n]))}(t),r=e.get(n.parentId);return r?{px:r.fisheye.x,py:r.fisheye.y}:null}function I(n){const t=(n=String(n).replace(/\s+/g,"")).split(/(;|\(|\)|,)/),e={parent:null,children:[]};let r=e,i=0;for(const n of t)if(n&&";"!==n)if("("===n){const n={parent:r,children:[]};r.children.push(n),r=n}else if(","===n){r=r.parent;const n={parent:r,children:[]};r.children.push(n),r=n}else if(")"===n){if(r=r.parent,null===r)break}else{const t=n.split(":");1===t.length?n.startsWith(":")?(r.label="",r.branchLength=parseFloat(t[0])):(r.label=t[0],r.branchLength=null):2===t.length?(r.label=t[0],r.branchLength=parseFloat(t[1])):(console.warn(n,"Unhandled token with multiple ':' characters"),r.label=t[0]||"",r.branchLength=parseFloat(t[t.length-1])),r.id=i++}return null==e.id&&(e.id=i),e}function g(n,t){let e={};n.data.forEach(n=>{e[n.thisId]={...n}});let r={};const i=function(n){e[n]&&(r[n]=e[n],e[n].children&&e[n].children.forEach(n=>{i(n)}))};i(t);const c=[["data",Object.values(r)]],a=c[0][1].map(n=>n.thisId);var s=[];for(const t in n)"data"!==t&&s.push([t,n[t]]);var o=s.map(n=>[n[0],n[1].filter(n=>a.includes(n.thisId))]);return Object.fromEntries(c.concat(o))}export{r as describeArc,p as parentFisheye,n as phisheye,h as radialLayout,I as readTree,u as rectangleLayout,g as subTree,f as unrooted};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@euphrasiologist/lwphylo",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "A lightweight, low level javascript library to plot phylogenies from Newick files.",
   "main": "dist/@euphrasiologist/lwphylo.js",
   "unpkg": "dist/@euphrasiologist/lwphylo.min.js",
@@ -33,9 +33,13 @@
   },
   "homepage": "https://github.com/Euphrasiologist/lwPhylo#readme",
   "devDependencies": {
-    "eslint": "6",
-    "jsdom": "15",
-    "rollup": "1",
-    "rollup-plugin-terser": "5"
+    "@eslint/js": "^9.37.0",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "eslint": "^9.37.0",
+    "globals": "^16.4.0",
+    "jsdom": "27",
+    "rollup": "^4.52.4"
   }
 }

package/src/phisheye/phisheye.js

@@ -1,69 +1,115 @@
-// based on https://github.com/d3/d3-plugins/blob/master/fisheye/fisheye.js
-// now archived d3 code?
+// Based on the archived d3 fisheye plugin, modernized & hardened.
+// - Works in screen/pixel space (set xscale/yscale).
+// - O(1) math with precomputed constants; avoids unnecessary sqrt.
+// - Stable API: .radius(), .distortion(), .focus(), .scales()
+// - Returns { x, y, z } where z ~= local magnification (clamped).
+// - Adds small ergonomics: .setScales(), .focusFromEvent(), .clampZ()
 
 const phisheye = {
-    circular: () => {
-        var radius = 200,
-            distortion = 2,
-            k0,
-            k1,
-            focus = [0, 0],
-            scales = {};
-
-        function fisheye(d) {
-            var dx = scales.xscale(d.x) - focus[0],
-                dy = scales.yscale(d.y) - focus[1],
-                dd = Math.sqrt(dx * dx + dy * dy);
-            if (!dd || dd >= radius)
-                return {
-                    x: scales.xscale(d.x),
-                    y: scales.yscale(d.y),
-                    z: dd >= radius ? 1 : 10
-                };
-            var k = ((k0 * (1 - Math.exp(-dd * k1))) / dd) * .75 + .25;
-            return {
-                x: focus[0] + dx * k,
-                y: focus[1] + dy * k,
-                z: Math.min(k, 10)
-            };
-        }
-
-        function rescale() {
-            k0 = Math.exp(distortion);
-            k0 = (k0 / (k0 - 1)) * radius;
-            k1 = distortion / radius;
-            return fisheye;
-        }
-
-        fisheye.radius = function (_) {
-            if (!arguments.length) return radius;
-            radius = +_;
-            return rescale();
-        };
-
-        fisheye.distortion = function (_) {
-            if (!arguments.length) return distortion;
-            distortion = +_;
-            return rescale();
-        };
-
-        fisheye.focus = function (_) {
-            if (!arguments.length) return focus;
-            focus = _;
-            return fisheye;
-        };
-
-        fisheye.scales = function (_, __) {
-            if (!arguments.length) return scales;
-            scales = {
-                xscale: _,
-                yscale: __
-            };
-            return fisheye;
-        };
-
-        return rescale();
+  circular: () => {
+    let radius = 200;        // pixels
+    let distortion = 2;      // dimensionless
+    let focus = [0, 0];      // [fx, fy] in pixels
+    let scales = {};         // { xscale, yscale }
+    let k0 = 0, k1 = 0;      // precomputed factors
+    let radius2 = radius * radius;
+    let zClamp = 10;         // max z (magnification) for stability
+
+    function ensureScales() {
+      if (!scales || typeof scales.xscale !== "function" || typeof scales.yscale !== "function") {
+        throw new Error("phisheye.circular: call .scales(xscale, yscale) before using the fisheye.");
+      }
+    }
+
+    function rescale() {
+      // Same functional form as the classic plugin:
+      // k = ((e^d) / (e^d - 1)) * R * (1 - exp(-d * r / R)) / r
+      // where d=distortion, R=radius, r=distance to focus.
+      const e = Math.exp(distortion);
+      k0 = (e / (e - 1)) * radius;  // constant multiplier
+      k1 = distortion / radius;     // exponent scale
+      radius2 = radius * radius;
+      return fisheye;
+    }
+
+    function fisheye(d) {
+      ensureScales();
+
+      const x0 = scales.xscale(d.x);
+      const y0 = scales.yscale(d.y);
+
+      const dx = x0 - focus[0];
+      const dy = y0 - focus[1];
+      const dd2 = dx * dx + dy * dy;
+
+      // At the focus or outside radius -> identity mapping, z ~ 1
+      if (dd2 === 0 || dd2 >= radius2) {
+        return { x: x0, y: y0, z: dd2 >= radius2 ? 1 : zClamp };
+      }
+
+      const dd = Math.sqrt(dd2);
+      // Classic mapping (with a slight blend for gentler core)
+      const k = ((k0 * (1 - Math.exp(-dd * k1))) / dd) * 0.75 + 0.25;
+
+      // New position
+      const x = focus[0] + dx * k;
+      const y = focus[1] + dy * k;
+
+      // Local magnification proxy (clamped)
+      const z = Math.min(k, zClamp);
+
+      return { x, y, z };
     }
-}
 
-export default phisheye
+    // --- Public API ---
+
+    fisheye.radius = function(_) {
+      if (!arguments.length) return radius;
+      radius = Math.max(0, +_);
+      return rescale();
+    };
+
+    fisheye.distortion = function(_) {
+      if (!arguments.length) return distortion;
+      distortion = Math.max(0, +_);
+      return rescale();
+    };
+
+    fisheye.focus = function(_) {
+      if (!arguments.length) return focus.slice();
+      if (!Array.isArray(_) || _.length !== 2) throw new Error("focus expects [x, y] in pixels.");
+      focus = [+_[0], +_[1]];
+      return fisheye;
+    };
+
+    fisheye.scales = function(xscale, yscale) {
+      if (!arguments.length) return scales;
+      scales = { xscale, yscale };
+      return fisheye;
+    };
+
+    // Convenience alias
+    fisheye.setScales = fisheye.scales;
+
+    // Clamp maximum z (magnification) returned; defaults to 10
+    fisheye.clampZ = function(_) {
+      if (!arguments.length) return zClamp;
+      zClamp = Math.max(1, +_);
+      return fisheye;
+    };
+
+    // Convenience: set focus from a pointer event relative to an HTMLElement/SVG
+    // Example: svg.on("pointermove", (e) => fe.focusFromEvent(e, svg.node()))
+    fisheye.focusFromEvent = function(event, element) {
+      const rect = element.getBoundingClientRect();
+      const fx = event.clientX - rect.left;
+      const fy = event.clientY - rect.top;
+      return fisheye.focus([fx, fy]);
+    };
+
+    return rescale();
+  }
+};
+
+export default phisheye;
+

package/src/radial/describeArc.js

@@ -1,22 +1,32 @@
-import polarToCartesian from "./polarToCartesian.js"
+import polarToCartesian from "./polarToCartesian.js";
 
 /**
- * Describe the arc to draw
- * https://stackoverflow.com/questions/5736398/how-to-calculate-the-svg-path-for-an-arc-of-a-circle
+ * Describe an SVG arc path between two angles (radians).
+ * Always draws the MINOR arc (≤ π). Angles are normalized to [0, 2π).
  */
+function normalize(theta) {
+  const t = theta % (2 * Math.PI);
+  return t < 0 ? t + 2 * Math.PI : t;
+}
 
-export default function (x, y, radius, startAngle, endAngle) {
+export default function describeArc(cx, cy, radius, startAngle, endAngle) {
+  let a0 = normalize(startAngle);
+  let a1 = normalize(endAngle);
 
-  var start = polarToCartesian(x, y, radius, startAngle);
-  var end = polarToCartesian(x, y, radius, endAngle);
+  // Choose the minor arc direction
+  let diff = a1 - a0;
+  if (diff <= -Math.PI) diff += 2 * Math.PI;
+  else if (diff > Math.PI) diff -= 2 * Math.PI;
 
-  // TODO: refers to middle zero below... but no large arcs needed..?
-  // var largeArcFlag = endAngle - startAngle <= Math.PI ? "0" : "1";
+  const largeArcFlag = Math.abs(diff) > Math.PI ? 1 : 0; // for completeness (will be 0 with minor arc)
+  const sweepFlag = diff >= 0 ? 1 : 0;
 
-  var d = [
+  const start = polarToCartesian(cx, cy, radius, a0);
+  const end = polarToCartesian(cx, cy, radius, a0 + diff);
+
+  return [
     "M", start.x, start.y,
-    "A", radius, radius, 0, 0, 0, end.x, end.y
+    "A", radius, radius, 0, largeArcFlag, sweepFlag, end.x, end.y
   ].join(" ");
+}
 
-  return d;
-}

package/src/radial/getArcs.js

@@ -1,61 +1,52 @@
-import reflectAngle from "./reflectAngle.js"
-
 /**
- * Takes parent data and returns a start value (radians),
- * end value (radians), and radius of circle to draw an 
- * arc from
+ * Build *per-edge* minor arcs for a radial tree.
+ * For each non-root node (child), we draw a small arc at the *parent's* radius
+ * from the parent's angle to the child's angle (minor arc ≤ π).
+ *
+ * Input: a "radialData" array with fields:
+ *   thisId, parentId, angle (radians), r (radius at this node)
+ *
+ * Output: [{ parentId, childId, radius, start, end }]
+ *   where start/end are angles (radians), radius is parent's r
  */
 
-export default function (pd) {
-  // must return start of arc and end
-  // these are pairs of edges that have the same parent
-  // start is the min(angle) of the children and end is the max(angle)
-  // radius is the radius of the parent
-  // origin is 0, 0 
-
-  var data = [];
-  var root = pd.map(d => d.parentId === null ? d.thisId : null).filter(d => d != null)[0];
-
-
-  // get the branchlength of the parentID
-  function sisterAngle(current_parentId) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].parentId === current_parentId) {
-        var sister_angle = pd[i].angle;
-      }
-    }
-    return sister_angle;
-  }
-
-  function parentRadius(current_parentId) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === current_parentId) {
-        var parent_r = pd[i].r;
-      }
-    }
-    return parent_r;
+function normalize(theta) {
+  const t = theta % (2 * Math.PI);
+  return t < 0 ? t + 2 * Math.PI : t;
+}
+
+function minorArc(a, b) {
+  // returns [start, end] representing the minor arc from a -> b
+  a = normalize(a); b = normalize(b);
+  let diff = b - a;
+  if (diff <= -Math.PI) diff += 2 * Math.PI;
+  else if (diff > Math.PI) diff -= 2 * Math.PI;
+  return [a, a + diff]; // draw from a to a+diff
+}
+
+export default function getArcs(pd) {
+  const byId = new Map(pd.map(d => [d.thisId, d]));
+  // Find root thisId
+  const root = pd.find(d => d.parentId == null)?.thisId;
+
+  const arcs = [];
+  for (const d of pd) {
+    if (d.thisId === root) continue;
+    const parent = byId.get(d.parentId);
+    if (!parent) continue;
+
+    // minor arc from parent.angle -> child.angle at radius parent.r
+    const [start, end] = minorArc(parent.angle, d.angle);
+
+    if (!isFinite(parent.r) || parent.r === 0 || start === end) continue;
+    arcs.push({
+      parentId: parent.thisId,
+      childId: d.thisId,
+      radius: parent.r,
+      start,
+      end
+    });
   }
+  return arcs;
+}
 
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].thisId !== root) {
-      data.push({
-        'start': reflectAngle(Math.min(pd[i].angle, sisterAngle(pd[i].parentId)), "Y"),
-        'end': reflectAngle(Math.max(pd[i].angle, sisterAngle(pd[i].parentId)), "Y"),
-        'radius': parentRadius(pd[i].parentId),
-        'thisId': pd[i].thisId,
-        'parentId': pd[i].parentId
-
-      })
-    }
-  }
-  //  TODO: understand why this works (and it may not in every case)... test!
-  for (let i = 0; i < data.length; i++) {
-    if (Math.sign(data[i].start) !== Math.sign(data[i].end)) {
-      data[i].end = Math.abs(data[i].end);
-      data[i].start = -Math.abs(data[i].start);
-    }
-  }
-
-  return data.filter(d => d.start !== d.end & d.radius !== 0);
-
-}

package/src/radial/getRadii.js

@@ -1,43 +1,37 @@
-import radialData from "./radialData.js"
+import radialData from "./radialData.js";
 
 /**
- * Take a parsed tree and get the radii of each of the nodes.
+ * Per-edge radial segments (for highlighting and drawing).
+ * For each non-root node, draw a radial line from the parent radius to the child radius
+ * at the CHILD'S angle.
+ *
+ * Output: [{ parentId, childId, x0, y0, x1, y1, isTip }]
  */
-
-export default function (node) {
-  var data = radialData(node);
-
-  // for the current iteration of the loop find the matching parentId
-  function getRadius(current_node) {
-    for (var i = 0; i < data.length; i++) {
-      if (data[i].thisId === current_node.parentId) {
-        var radius = data[i].r;
-      }
-    }
-    return radius;
+export default function getRadii(node) {
+  const data = radialData(node);
+  const byId = new Map(data.map(d => [d.thisId, d]));
+  const root = data.find(d => d.parentId == null)?.thisId;
+
+  const segments = [];
+  for (const d of data) {
+    if (d.thisId === root) continue;
+    const parent = byId.get(d.parentId);
+    if (!parent) continue;
+
+    const theta = d.angle;
+    const r0 = parent.r;
+    const r1 = d.r;
+
+    segments.push({
+      parentId: parent.thisId,
+      childId: d.thisId,
+      x0: r0 * Math.cos(theta),
+      y0: r0 * Math.sin(theta),
+      x1: r1 * Math.cos(theta),
+      y1: r1 * Math.sin(theta),
+      isTip: !!d.isTip
+    });
   }
+  return segments;
+}
 
-  var arcs = [];
-  // find root
-  var root = data.map(d => d.parentId === null ? d.thisId : null).filter(d => d != null)[0];
-
-  for (var i = 0; i < data.length; i++) {
-    if (data[i].thisId !== root) {
-
-      arcs.push({
-        'thisId': data[i].thisId,
-        'thisLabel': data[i].thisLabel,
-        'x0': data[i].x,
-        // radius of the parent * cos(angle)
-        'x1': getRadius(data[i]) * Math.cos(data[i].angle),
-        'y0': data[i].y,
-        // radius of the parent * sin(angle)
-        'y1': getRadius(data[i]) * Math.sin(data[i].angle),
-        'isTip': data[i].isTip
-      })
-    }
-  }
-
-  return arcs;
-
-}

package/src/radial/polarToCartesian.js

@@ -1,11 +1,9 @@
 /**
- * Convert polar co-ordinates to cartesian
- * https://stackoverflow.com/questions/5736398/how-to-calculate-the-svg-path-for-an-arc-of-a-circle
+ * Convert polar to Cartesian: angle in radians, 0 at +x, CCW positive.
  */
-
-export default function (centerX, centerY, radius, angleInRadians) {
+export default function polarToCartesian(cx, cy, r, angle) {
   return {
-    x: centerX + (radius * Math.cos(angleInRadians)),
-    y: centerY + (radius * Math.sin(angleInRadians))
+    x: cx + r * Math.cos(angle),
+    y: cy + r * Math.sin(angle)
   };
-}
+}

package/src/radial/radialData.js

@@ -1,102 +1,84 @@
 import fortify from "../utils/fortify.js"
-import numTips from "../utils/numTips.js"
-import mean from "../utils/mean.js"
 
 /**
- * Take a parsed tree and get the important data from them (i.e. radii, arcs).
+ * Compute per-node polar coordinates for radial layout:
+ *  - Tip angles: evenly spaced 0..2π in tip DFS order
+ *  - Internal angles: circular mean of child angles
+ *  - Radii: cumulative branch length from root
+ *  - x,y: cartesian projection
+ *
+ * Returns the fortified array with added {angle, r, x, y}.
  */
-
-export default function (node) {
-  // should start out the same as get_horizontal
-  // it's very similar in fact, but keeping separate for clarity.
-  var pd = fortify(node);
-
-  var tip_number = numTips(node);
-
-  // make tip angles
-  var tipID = 1;
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].isTip == true) {
-      pd[i].angle = (tipID / tip_number) * 2 * Math.PI;
-      tipID += 1;
-    }
+export default function radialData(node) {
+  const TAU = Math.PI * 2;
+  const norm = (t) => ((t % TAU) + TAU) % TAU;
+
+  const pd = fortify(node, /*sort*/ true);
+  const byId = new Map(pd.map(d => [d.thisId, d]));
+  const kids = new Map(pd.map(d => [d.thisId, d.children || []]));
+
+  // Find root id
+  let root = null;
+  for (const d of pd) {
+    if (d.parentId == null) { root = d.thisId; break; }
   }
 
-  // probably incredibly inefficient for large trees.
-  // gets the y values of two child branches by looping through the whole tree...
-  function internalNodeAngle(child_1, child_2) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === child_1) {
-        var angle_1 = pd[i].angle;
-      }
-      if (pd[i].thisId === child_2) {
-        var angle_2 = pd[i].angle;
-      }
+  // Collect tip ids in DFS left->right order to preserve input ordering
+  const tipIds = [];
+  (function dfs(id) {
+    const c = kids.get(id) || [];
+    if (c.length === 0) {
+      tipIds.push(id);
+      return;
     }
-    return mean([angle_1, angle_2]); // see utils.js
-  }
-
-  // if the node is not a tip...
-  for (let i = 0; i < pd.length; i++) {
-    if (pd[i].isTip === false) {
-      // then y0 === y1 and is the mean of the parental nodes
-      pd[i].angle = internalNodeAngle(pd[i].children[0], pd[i].children[1]);
-    }
-  }
-
-  // find root
-  var root = pd.map(d => d.parentId === null ? d.thisId : null).filter(d => d != null)[0];
-
-  // sort the data temporarily in decreasing parentId
-  pd.sort((a, b) => b.thisId - a.thisId);
-
-  // get the branchlength of the parentID
-  function getParentBranchLength(current_parentId) {
-    for (var i = 0; i < pd.length; i++) {
-      if (pd[i].thisId === current_parentId) {
-        var branchLength = pd[i].r;
+    for (const ch of c) dfs(ch);
+  })(root);
+
+  // Assign tip angles evenly spaced 0..2π
+  const N = Math.max(1, tipIds.length);
+  const angle = new Map();
+  tipIds.forEach((id, i) => {
+    angle.set(id, (i / N) * TAU);
+  });
+
+  // Internal node angles: circular mean of child angles (post-order)
+  (function setInternalAngles(id) {
+    const c = kids.get(id) || [];
+    for (const ch of c) setInternalAngles(ch);
+    if (c.length > 0) {
+      let sx = 0, sy = 0;
+      for (const ch of c) {
+        const th = angle.get(ch);
+        sx += Math.cos(th);
+        sy += Math.sin(th);
       }
+      angle.set(id, norm(Math.atan2(sy, sx)));
     }
-    return branchLength;
-  }
-
-  // assign depths (branch lengths) to radii
-  for (let i = 0; i < pd.length; i++) {
-    // special cases where parent is the root.
-    if (pd[i].parentId === root) {
-
-      if (pd[i].isTip === true) {
-        // radius is branch length at root?
-        pd[i].r = pd[i].branchLength;
-        pd[i].x = pd[i].branchLength;
-        pd[i].y = 0;
-
-      } else { // it's a node
-        // radius is branch length at root?
-        pd[i].r = pd[i].branchLength;
-        pd[i].x = pd[i].branchLength * Math.cos(pd[i].angle);
-        pd[i].y = pd[i].branchLength * Math.sin(pd[i].angle);
-      }
-
-    } else {
-      // the x0 is that of the parent
-      var parent_branchLength = getParentBranchLength(pd[i].parentId);
-      // the x1 is the sum of parent and current branchlength
-      pd[i].r = parent_branchLength + pd[i].branchLength;
-      // at the same time we can make x and y from polar coordinates
-      // this is creating some NaN's, may cause problems later.
-      pd[i].x = (parent_branchLength + pd[i].branchLength) * Math.cos(pd[i].angle);
-      pd[i].y = (parent_branchLength + pd[i].branchLength) * Math.sin(pd[i].angle);
+  })(root);
+
+  // Radii: cumulative branch lengths from root (root r=0)
+  const radius = new Map();
+  radius.set(root, 0);
+  (function setR(id) {
+    const c = kids.get(id) || [];
+    const r0 = radius.get(id) || 0;
+    for (const ch of c) {
+      const child = byId.get(ch);
+      const bl = child?.branchLength ?? 0;
+      radius.set(ch, r0 + bl);
+      setR(ch);
     }
+  })(root);
+
+  // Enrich pd rows with angle, r, x, y
+  for (const d of pd) {
+    const th = angle.get(d.thisId) ?? 0;
+    const r  = radius.get(d.thisId) ?? 0;
+    d.angle = th;
+    d.r = r;
+    d.x = r * Math.cos(th);
+    d.y = r * Math.sin(th);
   }
 
-  // at this point the first element is the root
-  pd[0].r = 0;
-  pd[0].x = 0;
-  pd[0].y = 0;
-
-  // return the original sorted data
-  //pd.sort((a,b) => a.thisId - b.thisId)
-
   return pd;
-}
+}