archaeopteryx 3.13.0 → 3.14.0

package/README.md

@@ -1059,7 +1059,38 @@ never at all on a tall screen. Growing the window back leaves the folds where
 they are: what is open is your choice, and only running out of room overrules
 it. Anything that puts something into a folded section opens it, so jumping to
 the search box (⌘F / Ctrl+F) or a tool reporting its result as search hits
-unfolds Search. A host with little room to give can
+unfolds Search. The **ⓘ** button in the panel header (or ⌘I / Ctrl+I) opens **Tree
+properties**, modelled on the desktop Archaeopteryx's *View › Tree
+Properties* and read-only:
+
+* **Tree** — name, description, identifier, type, branch-length unit,
+  rootedness and rerootability (each shown only where the file actually says
+  so), and "tree 2 of 3" when the file held several.
+* **Structure** — tips, internal nodes, total nodes, branches, whether the
+  tree is fully binary or how many polytomies it has and the widest of them,
+  depth from root to deepest tip, the longest tip label, and how many internal
+  nodes are named.
+* **Branch lengths** — how many branches carry one, then **minimum, median,
+  maximum and mean**, the sum as total tree length, the height from root to
+  farthest tip, any zero-length or negative branches, and whether the tree is
+  ultrametric.
+* **Support** — the same n / minimum / median / maximum / mean, **one section
+  per kind**. A bootstrap and a posterior on the same branch are not on one
+  scale, so they are never pooled; MAD values are not support and are counted
+  with the annotations instead.
+* **The tree carries** — taxonomies (and how many are distinct), taxonomy
+  identifiers, sequences, molecular sequences with the alignment width, domain
+  architectures, dates, distributions, events, branch colours, and **every
+  phyloXML property `ref` with the number of nodes carrying it** — each as
+  "n of m tips" or "n of m nodes".
+* **Time** — geologic ages or calendar years, dated nodes, the oldest node or
+  most recent tip, and whether there are confidence intervals.
+
+It describes what is on screen, so inside a subtree it describes the subtree
+and says so, and it is recomputed each time it opens rather than cached (24 ms
+on the 13,246-tip demo). There is no histogram.
+
+A host with little room to give can
 also start the whole panel tighter and narrower with
 [`panelDensity: 'compact'`](#configuration), or collapsed to its header bar
 with `collapseControlPanel`.

package/archaeopteryx.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.13.0
+// v 3.14.0
 // 2026-09-17
 //
 // Archaeopteryx.js is a software tool for the visualization and
@@ -103,7 +103,7 @@ function (root, d3, forester, phyloXml) {
     // IIFE's own function name -- a plain object says what it is.)
     let archaeopteryx = {};
 
-    const VERSION = '3.13.0';
+    const VERSION = '3.14.0';
     const WEBSITE = 'https://cmzmasek.github.io/archaeopteryx-js/';
     const DESKTOP_WEBSITE = 'https://cmzmasek.github.io/archaeopteryx/';
     const SOURCE_WEBSITE = 'https://github.com/cmzmasek/archaeopteryx-js';
@@ -414,6 +414,7 @@ function (root, d3, forester, phyloXml) {
     const BRANCH_SCALE_TIME_BUTTON = 'branch_scale_time_b';
     const BRANCH_SCALE_DIV_BUTTON = 'branch_scale_div_b';
     const ABOUT_DIALOG = 'aptx_about';
+    const TREE_PROPERTIES_DIALOG = 'aptx_tree_props';
     const PROG_NAME = 'progname';
     const PROGNAMELINK = 'prognamelink';
     const TREE_DESC = 'tree_desc';
@@ -9575,6 +9576,7 @@ function (root, d3, forester, phyloXml) {
         {key: 'g', label: 'G', shift: true, what: 'Previous search hit', run: function () { stepToFoundNode(-1); }, typing: true},
         {key: ',', label: '<', aliases: ['<'], shift: true, what: 'Previous tree of the file', run: function () { stepTree(-1); }},
         {key: '.', label: '>', aliases: ['>'], shift: true, what: 'Next tree of the file', run: function () { stepTree(1); }},
+        {key: 'i', label: 'I', what: 'Tree properties and statistics', run: showTreePropertiesDialog},
         {key: '/', label: '/', aliases: ['?'], what: 'This list', run: showShortcutsDialog, typing: true}
     ];
 
@@ -11738,7 +11740,7 @@ function (root, d3, forester, phyloXml) {
         if (matches.length > SUGGEST_MAX_ROWS) {
             let more = document.createElement('div');
             more.className = 'aptx-suggest-more';
-            more.textContent = (matches.length - SUGGEST_MAX_ROWS) + ' more — keep typing';
+            more.textContent = (matches.length - SUGGEST_MAX_ROWS) + ' more, keep typing';
             box.appendChild(more);
         }
         document.body.appendChild(box);
@@ -12165,7 +12167,7 @@ function (root, d3, forester, phyloXml) {
         }
         item.classList.toggle('aptx-check-active', !!active);
         item.title = active
-            ? item.dataset.baseTitle + ' — hiding now: 1 in ' + _dynahide_factor + ' labels shown'
+            ? item.dataset.baseTitle + ', hiding now: 1 in ' + _dynahide_factor + ' labels shown'
             : item.dataset.baseTitle;
     }
 
@@ -12795,6 +12797,15 @@ function (root, d3, forester, phyloXml) {
     }
 
     // The theme toggle, showing the theme it will switch TO.
+    // A circled "i": the tree-properties button. The stem is a stroke and the
+    // tittle a filled dot, so both keep their shape at the 20px the header
+    // button draws them at.
+    function glyphInfo() {
+        return '<circle cx="50" cy="50" r="40"/>'
+            + glyphLine(50, 45, 50, 71)
+            + glyphDot(50, 29, 5.5);
+    }
+
     function glyphSun() {
         let s = glyphDot(50, 50, 20);
         for (let i = 0; i < 8; ++i) {
@@ -12862,6 +12873,7 @@ function (root, d3, forester, phyloXml) {
             case 'uncollapse_all': sw = 8.5; cap = 'round'; body = glyphUncollapseAll(); break;
             case 'tree_prev': sw = 9; cap = 'round'; body = glyphChevron(false); break;
             case 'tree_next': sw = 9; cap = 'round'; body = glyphChevron(true); break;
+            case 'info': sw = 7; cap = 'round'; body = glyphInfo(); break;
             case 'sun': body = glyphSun(); break;
             case 'moon': body = glyphMoon(); break;
             default: throw new Error('unknown control-panel glyph: ' + kind);
@@ -13000,7 +13012,14 @@ function (root, d3, forester, phyloXml) {
             + '@media (prefers-reduced-motion:reduce){ .aptx-busy-dot { animation:none;'
             + '  border-color:var(--p-accent); } }'
             + '.aptx-busy-sub { color:var(--p-muted); }'
+            // The same frosted glass as the node menu and the suggestion list:
+            // --p-bg is deliberately translucent (0.86) so panels float over
+            // the tree, but without the blur a dialog puts dense text straight
+            // on top of whatever is behind it -- and over an alignment or a
+            // heat map that is a rainbow. The menus had the blur from the
+            // start; the dialogs were simply missed.
             + '.aptx-dialog { padding:0; border:1px solid var(--p-line-strong); border-radius:12px;'
+            + '  -webkit-backdrop-filter:blur(8px); backdrop-filter:blur(8px);'
             + '  background:var(--p-bg); color:var(--p-ink); max-width:92vw;'
             + '  box-shadow:0 24px 48px -16px rgba(23,34,46,0.45),0 4px 12px -4px rgba(23,34,46,0.22);'
             + '  font-family:system-ui,-apple-system,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;'
@@ -13045,6 +13064,9 @@ function (root, d3, forester, phyloXml) {
             + '.aptx-dialog-key { flex:0 0 42%; color:var(--p-muted); }'
             + '.aptx-dialog-val { flex:1 1 auto; min-width:0; overflow-wrap:anywhere; }'
             // the shortcuts cheat sheet: key chips in the key column
+            + '.aptx-props .aptx-props-head { font-size:10px; letter-spacing:.08em; text-transform:uppercase; color:var(--p-muted); margin:12px 0 3px; }'
+            + '.aptx-props > div:first-child { margin-top:0; }'
+            + '.aptx-props .aptx-dialog-key { flex-basis:46%; }'
             + '.aptx-shortcuts .aptx-dialog-key { flex-basis:38%; display:flex; align-items:center; }'
             + '.aptx-shortcuts .aptx-dialog-val { align-self:center; }'
             + '.aptx-keys { display:inline-flex; gap:3px; flex-wrap:wrap; }'
@@ -13199,7 +13221,7 @@ function (root, d3, forester, phyloXml) {
             + '.aptx-panel .aptx-seg:has(> input:checked) { background:var(--p-accent); color:#fff; }'
             + '.aptx-panel .aptx-seg:has(> input:disabled) { opacity:0.4; cursor:default; }'
             + '.aptx-panel .aptx-actions { margin-left:auto; display:flex; align-items:center; gap:5px; }'
-            + '.aptx-panel .aptx-theme-btn { flex:none; width:20px; height:20px; display:grid; place-items:center; padding:0; border:1px solid var(--p-line-strong); border-radius:6px; background:var(--p-surface2); color:var(--p-muted); cursor:pointer; font-size:12px; line-height:1; }'
+            + '.aptx-panel .aptx-theme-btn, .aptx-panel .aptx-info-btn { flex:none; width:20px; height:20px; display:grid; place-items:center; padding:0; border:1px solid var(--p-line-strong); border-radius:6px; background:var(--p-surface2); color:var(--p-muted); cursor:pointer; font-size:12px; line-height:1; }'
             + '.aptx-panel .aptx-theme-btn:hover { background:var(--p-accent-weak); color:var(--p-accent-ink); border-color:var(--p-accent); }'
             + '.aptx-panel input[type=range] { -webkit-appearance:none; appearance:none; display:block; width:100%; height:15px; margin:2px 0 9px; padding:0; background:transparent; cursor:pointer; }'
             + '.aptx-panel input[type=range]::-webkit-slider-runnable-track { height:4px; border-radius:999px; background:var(--p-line-strong); }'
@@ -13354,6 +13376,24 @@ function (root, d3, forester, phyloXml) {
             let actions = document.createElement('div');
             actions.className = 'aptx-actions';
 
+            let infoBtn = document.createElement('button');
+            infoBtn.type = 'button';
+            // NOT aptx-theme-btn: applyPanelTheme repaints the innerHTML of
+            // every element carrying that class with the sun/moon, so
+            // borrowing it for the chrome replaced this glyph the instant a
+            // theme was applied. The two share their styling through the CSS
+            // selector instead, which is all the class was wanted for.
+            infoBtn.className = 'aptx-info-btn';
+            infoBtn.title = 'Tree properties and statistics ('
+                + (IS_MAC ? '\u2318I' : 'Ctrl+I') + ')';
+            infoBtn.setAttribute('aria-label', 'Tree properties and statistics');
+            infoBtn.innerHTML = makeGlyph('info');
+            infoBtn.addEventListener('click', function (e) {
+                e.stopPropagation();
+                showTreePropertiesDialog();
+            });
+            actions.appendChild(infoBtn);
+
             let progName = header.querySelector('.' + PROGNAMELINK);
             if (progName) {
                 // Clicking the title used to navigate away to the project site;
@@ -13927,6 +13967,257 @@ function (root, d3, forester, phyloXml) {
         shell.dialog.showModal();
     }
 
+    // ===================== Tree properties =====================
+    // What the tree IS and what it carries: the desktop's View > Tree
+    // Properties, read-only (Christian, 2026-09-23 -- the editable half waits
+    // for demand). Nothing else in the viewer answers "what is actually in
+    // this file", which is the first question a tree raises.
+    //
+    // Computed FRESH every time it opens rather than cached: the whole of
+    // collectBasicTreeProperties costs 7ms on the 13,246-tip H5N1 demo, and a
+    // cache would go stale the moment the user re-roots or enters a subtree.
+    // It describes what is ON SCREEN, so in a subtree it describes the
+    // subtree, and says so.
+    //
+    // Every value goes in through textContent. Tree names, descriptions and
+    // identifiers are file data, and file data never becomes markup.
+
+    function treePropRow(parent, label, value) {
+        if (value === null || value === undefined || value === '') {
+            return;
+        }
+        let line = document.createElement('div');
+        line.className = 'aptx-dialog-line';
+        let k = document.createElement('span');
+        k.className = 'aptx-dialog-key';
+        k.textContent = label;
+        let v = document.createElement('span');
+        v.className = 'aptx-dialog-val';
+        v.textContent = String(value);
+        line.appendChild(k);
+        line.appendChild(v);
+        parent.appendChild(line);
+    }
+
+    function treePropSection(body, title) {
+        let h = document.createElement('div');
+        h.className = 'aptx-props-head';
+        h.textContent = title;
+        body.appendChild(h);
+        let box = document.createElement('div');
+        body.appendChild(box);
+        return box;
+    }
+
+    function countNumber(n) {
+        return (typeof n === 'number' && isFinite(n)) ? n.toLocaleString() : null;
+    }
+
+    // A number for a fact row: thousands separators for counts, and enough
+    // significant digits for a branch length, which can be 5e-9.
+    function statNumber(v, digits) {
+        if (typeof v !== 'number' || !isFinite(v)) {
+            return null;
+        }
+        if (v === 0 || (Math.abs(v) >= 0.001 && Math.abs(v) < 1e7)) {
+            return String(forester.roundNumber(v, digits === undefined ? 6 : digits));
+        }
+        return v.toExponential(3);
+    }
+
+    // "1,234 of 5,678 tips", the desktop's coverage phrasing.
+    function statOf(part, whole, noun) {
+        if (!(whole > 0)) {
+            return null;
+        }
+        return countNumber(part) + ' of ' + countNumber(whole) + (noun ? (' ' + noun) : '');
+    }
+
+    // n / minimum / median / maximum / mean, the block Christian asked for in
+    // place of a histogram. One shape, used for branch lengths and for each
+    // kind of support, so the two read the same way.
+    function statSpread(box, d, digits) {
+        treePropRow(box, 'Minimum', statNumber(d.min, digits));
+        treePropRow(box, 'Median', statNumber(d.median, digits));
+        treePropRow(box, 'Maximum', statNumber(d.max, digits));
+        treePropRow(box, 'Mean', statNumber(d.mean, digits));
+    }
+
+    function showTreePropertiesDialog() {
+        if (!_root) {
+            return;
+        }
+        let shell = makeDialogShell(TREE_PROPERTIES_DIALOG, 'Tree properties', 420);
+        shell.body.classList.add('aptx-props');
+        // A description is free text and can be a paragraph, and the coverage
+        // section grows with the annotations, so the body scrolls rather than
+        // running off the screen.
+        shell.body.style.maxHeight = '66vh';
+        shell.body.style.overflowY = 'auto';
+        let st = forester.treeStatistics(_root);
+        let bp = forester.collectBasicTreeProperties(_root);
+        let time = forester.timeAxisInfo(_root);
+        let phy = _treeData || {};
+
+        // --- what the tree says it is ---------------------------------
+        let box = treePropSection(shell.body, 'Tree');
+        treePropRow(box, 'Name', phy.name);
+        treePropRow(box, 'Description', phy.description);
+        if (phy.id && phy.id.value) {
+            treePropRow(box, 'Identifier', phy.id.provider
+                ? (phy.id.value + '  (' + phy.id.provider + ')') : phy.id.value);
+        }
+        treePropRow(box, 'Type', phy.type);
+        treePropRow(box, 'Branch-length unit', phy.branch_length_unit);
+        // Only when the FILE said so. phyloXML has a rooted attribute and a
+        // Nexus tree statement has [&R]/[&U]; plain Newick says nothing, and a
+        // properties dialog that answered "yes" there would be reporting our
+        // writing default as though the file had stated it.
+        if (typeof phy.rooted === 'boolean') {
+            treePropRow(box, 'Rooted', phy.rooted ? 'yes' : 'no');
+        }
+        if (typeof phy.rerootable === 'boolean') {
+            treePropRow(box, 'Rerootable', phy.rerootable ? 'yes' : 'no');
+        }
+        if (_trees && _trees.length > 1) {
+            treePropRow(box, 'In this file', 'tree ' + (_treeIndex + 1) + ' of ' + _trees.length);
+        }
+        if (_in_subtree) {
+            treePropRow(box, 'Showing', 'a subtree, not the whole tree');
+        }
+        if (!box.firstChild) {
+            treePropRow(box, 'Name', '(the tree carries no name or metadata)');
+        }
+
+        // --- shape ----------------------------------------------------
+        box = treePropSection(shell.body, 'Structure');
+        treePropRow(box, 'Tips', countNumber(st.tips));
+        treePropRow(box, 'Internal nodes', countNumber(st.internal));
+        treePropRow(box, 'Nodes, total', countNumber(st.nodes));
+        treePropRow(box, 'Branches', countNumber(st.branches));
+        treePropRow(box, 'Branching', st.polytomies === 0 ? 'fully binary'
+            : (countNumber(st.polytomies) + (st.polytomies === 1 ? ' polytomy' : ' polytomies')
+                + ', widest ' + countNumber(st.maxChildren) + ' children'));
+        treePropRow(box, 'Depth', countNumber(st.depth) + ' (root to deepest tip)');
+        // ours, not the desktop's, and worth keeping: the label width is what
+        // decides how much room the tree needs, and whether internal nodes are
+        // named decides whether their labels are worth turning on
+        treePropRow(box, 'Longest tip label', bp.longestNodeName > 0
+            ? (countNumber(bp.longestNodeName)
+                + (bp.longestNodeName === 1 ? ' character' : ' characters')) : null);
+        treePropRow(box, 'Internal nodes named', st.internal > 0
+            ? (st.namedInternal > 0 ? statOf(st.namedInternal, st.internal) : 'none') : null);
+
+        // --- branch lengths -------------------------------------------
+        box = treePropSection(shell.body, 'Branch lengths');
+        if (st.branchLengths) {
+            treePropRow(box, 'Branches with a length',
+                statOf(st.branchLengths.n, st.branches));
+            statSpread(box, st.branchLengths);
+            treePropRow(box, 'Sum', statNumber(st.branchLengths.sum) + ' (total tree length)');
+            treePropRow(box, 'Height', statNumber(st.height) + ' (root to farthest tip)');
+            if (st.branchLengths.zero > 0) {
+                treePropRow(box, 'Zero-length', countNumber(st.branchLengths.zero));
+            }
+            if (st.branchLengths.negative > 0) {
+                treePropRow(box, 'Negative', countNumber(st.branchLengths.negative)
+                    + ' (not drawn to scale)');
+            }
+            treePropRow(box, 'Ultrametric', st.ultrametric
+                ? 'yes (every tip the same distance from the root)' : 'no');
+        } else {
+            treePropRow(box, 'Branches with a length', 'none, the tree has no lengths');
+        }
+
+        // --- support, one section per kind ----------------------------
+        // A bootstrap and a posterior on the same branch are not on one scale,
+        // so they are never pooled: each type gets its own n and spread.
+        st.support.forEach(function (d) {
+            // 'unknown' is what the Newick and Nexus readers put on a bare
+            // [95]: those formats have one support slot and nowhere to name
+            // what it is, so it is an absence of type rather than a type
+            // called unknown, and it should not head a section as one.
+            let untyped = !d.type || d.type === 'unknown';
+            let title = (st.support.length === 1 && untyped)
+                ? 'Support values' : ('Support: ' + (untyped ? 'untyped' : d.type));
+            let sbox = treePropSection(shell.body, title);
+            treePropRow(sbox, 'Branches with support', statOf(d.n, st.branches));
+            statSpread(sbox, d);
+        });
+
+        // --- what came with it ----------------------------------------
+        box = treePropSection(shell.body, 'The tree carries');
+        let carried = 0;
+        function carries(label, present, detail) {
+            if (!present) {
+                return;
+            }
+            ++carried;
+            treePropRow(box, label, detail || 'yes');
+        }
+        carries('Taxonomies', st.tipsWithTaxonomy > 0, statOf(st.tipsWithTaxonomy, st.tips, 'tips')
+            + (st.distinctTaxonomies > 0 ? (', ' + countNumber(st.distinctTaxonomies) + ' distinct') : ''));
+        carries('Taxonomy identifiers', st.tipsWithTaxonomyId > 0,
+            statOf(st.tipsWithTaxonomyId, st.tips, 'tips'));
+        carries('Sequences', st.tipsWithSequence > 0, statOf(st.tipsWithSequence, st.tips, 'tips'));
+        // alignedMolSeqs starts TRUE and is only ever set false, so it means
+        // "no UNALIGNED sequence was seen" -- a tree carrying no sequences at
+        // all reports true. Read alone it told the flu and ammonite demos they
+        // had an alignment. Every other reader in this file pairs it with a
+        // length for the same reason.
+        carries('Molecular sequences', st.tipsWithMolSeq > 0,
+            statOf(st.tipsWithMolSeq, st.tips, 'tips')
+            + (bp.alignedMolSeqs && bp.maxMolSeqLength > 0
+                ? (', aligned, ' + countNumber(bp.maxMolSeqLength) + ' columns') : ''));
+        carries('Domain architectures', st.tipsWithDomains > 0,
+            statOf(st.tipsWithDomains, st.tips, 'tips')
+            + (bp.maxDomainArchitectureLength > 0
+                ? (', up to ' + countNumber(bp.maxDomainArchitectureLength) + ' residues') : ''));
+        carries('Dates', st.nodesWithDate > 0, statOf(st.nodesWithDate, st.nodes, 'nodes'));
+        carries('Distributions', st.tipsWithDistribution > 0,
+            statOf(st.tipsWithDistribution, st.tips, 'tips'));
+        carries('MAD values', bp.madValues);
+        carries('Branch colours', bp.branchColors);
+        if (st.nodesWithEvents > 0) {
+            let parts = [];
+            if (st.duplications > 0) {
+                parts.push(countNumber(st.duplications)
+                    + (st.duplications === 1 ? ' duplication' : ' duplications'));
+            }
+            if (st.speciations > 0) {
+                parts.push(countNumber(st.speciations)
+                    + (st.speciations === 1 ? ' speciation' : ' speciations'));
+            }
+            parts.push(statOf(st.nodesWithEvents, st.nodes, 'nodes'));
+            carries('Events', true, parts.join(', '));
+        }
+        st.propertyRefs.forEach(function (r) {
+            carries('Property ' + r.ref, true, statOf(r.nodes, st.nodes, 'nodes'));
+        });
+        if (carried === 0) {
+            treePropRow(box, 'Annotations', 'none, names and topology only');
+        }
+
+        // --- time -----------------------------------------------------
+        if (time && (time.type || time.dated)) {
+            box = treePropSection(shell.body, 'Time');
+            treePropRow(box, 'Dates', time.type === 'geologic'
+                ? 'geologic ages' : (time.type === 'calendar' ? 'calendar years' : 'yes'));
+            treePropRow(box, 'Dated nodes', statOf(st.nodesWithDate, st.nodes, 'nodes')
+                + (time.dated ? ' (a dated tree)' : ''));
+            if (time.type === 'geologic' && time.rootAge > 0) {
+                treePropRow(box, 'Oldest node', statNumber(time.rootAge, 4) + ' Ma');
+            }
+            if (time.type === 'calendar' && time.presentDate > 0) {
+                treePropRow(box, 'Most recent tip', statNumber(time.presentDate, 4));
+            }
+            treePropRow(box, 'Confidence intervals',
+                (time.hasInternalIntervals || time.hasExternalIntervals) ? 'yes' : null);
+        }
+
+        shell.dialog.showModal();
+    }
+
     // The About box behind the panel's title. Everything here is fixed text and
     // fixed URLs -- no tree data reaches it -- so the links are built as real
     // elements rather than markup.

package/forester.js

@@ -20,7 +20,7 @@
  *
  */
 
-// v 3.13.0
+// v 3.14.0
 // 2026-09-17
 //
 // forester.js is a general suite for dealing with phylogenetic trees.
@@ -3814,6 +3814,230 @@
     };
 
 
+    // Everything the Tree Properties dialog reports, gathered in ONE pass:
+    // the desktop's TreeFacts.scan, minus its histogram (Christian, 2026-09-23:
+    // "we don't need a histogram ... but a more detailed stats would be
+    // useful, min, median, max, n, also type ... also need to include the
+    // properties").
+    //
+    // Side-effect free and DOM-free, so it can be tested in Node -- the whole
+    // reason it lives here rather than in the dialog that renders it, which is
+    // the same split the desktop makes between TreeFacts and
+    // TreePropertiesForm.
+    //
+    // Support values are grouped BY TYPE, because a tree can carry a bootstrap
+    // and a posterior on the same branch and their ranges are not comparable
+    // (0-100 against 0-1); averaging them together would produce a number that
+    // describes neither. MAD values are excluded for the same reason they are
+    // excluded from the Newick support slot: they rate a root position, not a
+    // clade.
+    forester.treeStatistics = function (phyOrNode) {
+        // Callers hand this either a phylogeny wrapper or the root node, and
+        // the difference is one extra internal node, one extra branch and one
+        // more of depth -- small enough to read as plausible. getTreeRoot
+        // normalizes both, as collectBasicTreeProperties does.
+        let root = phyOrNode ? forester.getTreeRoot(phyOrNode) : null;
+        let stats = {
+            tips: 0, internal: 0, nodes: 0, branches: 0,
+            polytomies: 0, maxChildren: 0,
+            depth: 0, height: 0, heightKnown: false,
+            collapsed: 0,
+            branchLengths: null,
+            support: [],
+            ultrametric: false,
+            tipsWithTaxonomy: 0, distinctTaxonomies: 0, tipsWithTaxonomyId: 0,
+            tipsWithSequence: 0, tipsWithMolSeq: 0, tipsWithDomains: 0,
+            nodesWithDate: 0, tipsWithDistribution: 0, namedInternal: 0,
+            duplications: 0, speciations: 0, nodesWithEvents: 0,
+            propertyRefs: []
+        };
+        if (!root) {
+            return stats;
+        }
+        let lengths = [];
+        let zeroLengths = 0;
+        let negativeLengths = 0;
+        let byType = Object.create(null);
+        let taxa = Object.create(null);
+        let refs = Object.create(null);
+        let refOrder = [];
+        let tipDepths = [];
+        let maxDepth = 0;
+
+        (function walk(n, depth, distance) {
+            ++stats.nodes;
+            let kids = n.children || [];
+            if (depth > maxDepth) {
+                maxDepth = depth;
+            }
+            if (n !== root) {
+                ++stats.branches;
+                let b = n.branch_length;
+                if (typeof b === 'number' && isFinite(b)) {
+                    lengths.push(b);
+                    if (b === 0) {
+                        ++zeroLengths;
+                    } else if (b < 0) {
+                        ++negativeLengths;
+                    }
+                    distance += b;
+                }
+            }
+            // support, by type, MAD left out
+            if (n.confidences) {
+                for (let i = 0; i < n.confidences.length; ++i) {
+                    let c = n.confidences[i];
+                    if (c.type === forester.MAD_CONFIDENCE_TYPE) {
+                        continue;
+                    }
+                    if (typeof c.value !== 'number' || !isFinite(c.value)) {
+                        continue;
+                    }
+                    let key = c.type || '';
+                    if (!byType[key]) {
+                        byType[key] = [];
+                        stats.support.push({type: key, values: byType[key]});
+                    }
+                    byType[key].push(c.value);
+                }
+            }
+            if (n.date && typeof n.date.value === 'number' && isFinite(n.date.value)) {
+                ++stats.nodesWithDate;
+            }
+            if (n.properties) {
+                let seen = Object.create(null);
+                for (let i = 0; i < n.properties.length; ++i) {
+                    let ref = n.properties[i] && n.properties[i].ref;
+                    if (!ref || seen[ref]) {
+                        continue;   // a node carrying a ref twice counts once
+                    }
+                    seen[ref] = true;
+                    if (refs[ref] === undefined) {
+                        refs[ref] = 0;
+                        refOrder.push(ref);
+                    }
+                    ++refs[ref];
+                }
+            }
+            if (n.events) {
+                ++stats.nodesWithEvents;
+                if (n.events.duplications > 0) {
+                    stats.duplications += n.events.duplications;
+                }
+                if (n.events.speciations > 0) {
+                    stats.speciations += n.events.speciations;
+                }
+            }
+            if (kids.length > 0) {
+                ++stats.internal;
+                if (kids.length > stats.maxChildren) {
+                    stats.maxChildren = kids.length;
+                }
+                if (kids.length > 2) {
+                    ++stats.polytomies;
+                }
+                if (n !== root && n.name) {
+                    ++stats.namedInternal;
+                }
+                for (let i = 0; i < kids.length; ++i) {
+                    walk(kids[i], depth + 1, distance);
+                }
+                return;
+            }
+            ++stats.tips;
+            tipDepths.push(distance);
+            if (n.taxonomies && n.taxonomies.length > 0) {
+                ++stats.tipsWithTaxonomy;
+                let t = n.taxonomies[0];
+                let label = t.scientific_name || t.code || t.common_name || '';
+                if (label) {
+                    taxa[label] = true;
+                }
+                if (t.id && t.id.value) {
+                    ++stats.tipsWithTaxonomyId;
+                }
+            }
+            if (n.sequences && n.sequences.length > 0) {
+                ++stats.tipsWithSequence;
+                let q = n.sequences[0];
+                if (q.mol_seq && q.mol_seq.value) {
+                    ++stats.tipsWithMolSeq;
+                }
+                if (forester.domainArchitectureOf(n)) {
+                    ++stats.tipsWithDomains;
+                }
+            }
+            if (n.distributions && n.distributions.length > 0) {
+                ++stats.tipsWithDistribution;
+            }
+        })(root, 0, 0);
+
+        stats.depth = maxDepth;
+        stats.distinctTaxonomies = Object.keys(taxa).length;
+        stats.propertyRefs = refOrder.map(function (r) {
+            return {ref: r, nodes: refs[r]};
+        });
+        stats.branchLengths = forester.describeValues(lengths);
+        if (stats.branchLengths) {
+            stats.branchLengths.zero = zeroLengths;
+            stats.branchLengths.negative = negativeLengths;
+        }
+        stats.support = stats.support.map(function (g) {
+            let d = forester.describeValues(g.values);
+            d.type = g.type;
+            return d;
+        }).filter(function (d) {
+            return d.n > 0;
+        });
+        if (tipDepths.length > 0) {
+            // running, not Math.min.apply: the spread of 150k tip depths
+            // overflows the call stack, as timeAxisInfo found before this
+            let lo = Infinity;
+            let hi = -Infinity;
+            for (let i = 0; i < tipDepths.length; ++i) {
+                if (tipDepths[i] < lo) {
+                    lo = tipDepths[i];
+                }
+                if (tipDepths[i] > hi) {
+                    hi = tipDepths[i];
+                }
+            }
+            stats.height = hi;
+            stats.heightKnown = lengths.length > 0;
+            // ultrametric: every tip the same distance from the root, to a
+            // tolerance scaled to the tree, since branch lengths are floats
+            stats.ultrametric = stats.heightKnown && (hi - lo) <= (Math.max(hi, 1e-12) * 1e-6);
+        }
+        return stats;
+    };
+
+    // n, minimum, median, maximum, mean and sum of a list of numbers, or null
+    // when there are none. The median is the middle value of the sorted list,
+    // or the mean of the two middle ones -- taken on a COPY, because sorting
+    // the caller's array would reorder data it still owns.
+    forester.describeValues = function (values) {
+        if (!values || values.length === 0) {
+            return null;
+        }
+        let v = values.slice().sort(function (a, b) {
+            return a - b;
+        });
+        let n = v.length;
+        let sum = 0;
+        for (let i = 0; i < n; ++i) {
+            sum += v[i];
+        }
+        let mid = Math.floor(n / 2);
+        return {
+            n: n,
+            min: v[0],
+            max: v[n - 1],
+            median: (n % 2 === 1) ? v[mid] : ((v[mid - 1] + v[mid]) / 2),
+            mean: sum / n,
+            sum: sum
+        };
+    };
+
     forester.calcMaxBranchLength = function (node) {
         let max = 0;
         forester.preOrderTraversalAll(node, function (n) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archaeopteryx",
-  "version": "3.13.0",
+  "version": "3.14.0",
   "description": "Archaeopteryx.js is a software tool for the visualization and analysis of highly annotated phylogenetic trees.",
   "main": "archaeopteryx.js",
   "types": "archaeopteryx.d.ts",