@rokkit/graph 1.7.0 → 1.8.1

package/dist/layout/extent.js

@@ -0,0 +1,27 @@
+/** Bottom-right extent of a set of boxes (a box with no size is a point), or {0,0}. */
+function extentOf(boxes) {
+    let w = 0;
+    let h = 0;
+    for (const box of boxes) {
+        w = Math.max(w, box.x + (box.w ?? 0));
+        h = Math.max(h, box.y + (box.h ?? 0));
+    }
+    return { w, h };
+}
+/**
+ * The true content extent of a layout, as distinct from its `size`.
+ *
+ * `LayoutResult.size` adds a +60 margin on the right and bottom only, so fitting to it hugs the
+ * left/top edge and floats away from the right/bottom. Centring needs the real bounds: the
+ * clusters', or — for an ungrouped layout (neighborhood), which reports none — the cards', and
+ * the layout size only when both are empty.
+ */
+export function contentExtent(clusters, cards, size) {
+    let { w, h } = extentOf(clusters);
+    if (!w || !h) {
+        const fromCards = extentOf(Object.values(cards));
+        w = Math.max(w, fromCards.w);
+        h = Math.max(h, fromCards.h);
+    }
+    return { w: w || size.w, h: h || size.h };
+}

package/dist/layout/flow.js

@@ -13,6 +13,7 @@
  * edge is still drawn straight over any box between its endpoints, because routing it around
  * needs dummy nodes on the intervening ranks and that is its own slice.
  */
+import { carried } from './edges.js';
 import { buildCards } from './cards.js';
 import { rank } from './rank.js';
 import { order } from './order.js';
@@ -65,7 +66,8 @@ function identity(edge, i) {
         fromKey: edge.source,
         toKey: edge.target,
         kind: edge.kind,
-        relation: edge.relation
+        relation: edge.relation,
+        ...carried(edge)
     };
 }
 /**

package/dist/layout/index.d.ts

@@ -1,8 +1,11 @@
+import { arcs } from './arcs.js';
 import { cluster } from './cluster.js';
 import { flow } from './flow.js';
+import { layers } from './layers.js';
 import { neighborhood } from './neighborhood.js';
 import { world } from './world.js';
 import { points } from './points.js';
+import { polymetric } from './polymetric.js';
 import { radial } from './radial.js';
 import { structure } from './structure.js';
 import { sunburst } from './sunburst.js';
@@ -10,6 +13,6 @@ import type { LayoutFn } from './types.js';
 /** Built-in layouts, addressable by name from `Graph`'s `layout` prop. */
 export declare const layouts: Record<string, LayoutFn>;
 export type LayoutName = keyof typeof layouts;
-export { cluster, flow, neighborhood, points, radial, structure, sunburst, world };
+export { arcs, cluster, flow, layers, neighborhood, points, polymetric, radial, structure, sunburst, world };
 export { LAYOUT_OPTIONS, appliesTo } from './options.js';
 export * from './types.js';

package/dist/layout/index.js

@@ -1,13 +1,28 @@
+import { arcs } from './arcs.js';
 import { cluster } from './cluster.js';
 import { flow } from './flow.js';
+import { layers } from './layers.js';
 import { neighborhood } from './neighborhood.js';
 import { world } from './world.js';
 import { points } from './points.js';
+import { polymetric } from './polymetric.js';
 import { radial } from './radial.js';
 import { structure } from './structure.js';
 import { sunburst } from './sunburst.js';
 /** Built-in layouts, addressable by name from `Graph`'s `layout` prop. */
-export const layouts = { cluster, flow, neighborhood, points, radial, structure, sunburst, world };
-export { cluster, flow, neighborhood, points, radial, structure, sunburst, world };
+export const layouts = {
+    arcs,
+    cluster,
+    flow,
+    layers,
+    neighborhood,
+    points,
+    polymetric,
+    radial,
+    structure,
+    sunburst,
+    world
+};
+export { arcs, cluster, flow, layers, neighborhood, points, polymetric, radial, structure, sunburst, world };
 export { LAYOUT_OPTIONS, appliesTo } from './options.js';
 export * from './types.js';

package/dist/layout/layers.d.ts

@@ -0,0 +1,6 @@
+import type { LayoutFn } from './types.js';
+import type { Conformance } from '../types.js';
+/** How an edge sits against the layering, from the two layers the host gave. */
+export declare function deriveConformance(from?: number, to?: number): Conformance | undefined;
+/** Host-assigned layers as horizontal bands, layer 0 at the top. */
+export declare const layers: LayoutFn;

package/dist/layout/layers.js

@@ -0,0 +1,180 @@
+/* The layered view (#167): modules ranked into horizontal layers, foundations at the bottom.
+ *
+ * Sugiyama-shaped, but the expensive half — assigning layers — is the HOST's: it knows the
+ * intended architecture, and rokkit computes no depth. What is left is placement and the
+ * one thing the view exists to show: edges should only point DOWN, and the ones that climb are
+ * violations.
+ *
+ *   - one full-width band per layer, layer 0 at the top, drawn as a cluster box so it renders
+ *     through the existing box path with its label;
+ *   - a crowded layer wraps into rows rather than one line a thousand cards long;
+ *   - a layer is ordered by one barycenter pass against the layer above — each node under the
+ *     mean position of its neighbours there — which removes most of the avoidable crossings;
+ *   - edges are vertical S-curves, and carry their conformance for the theme to colour.
+ */
+import { buildCards } from './cards.js';
+import { CARD_W } from './constants.js';
+import { carried, keepsEdge } from './edges.js';
+import { warnUnknownOptions } from './options.js';
+import { say } from '../messages.js';
+/** Cards per row before a layer wraps. */
+const PER_ROW = 8;
+const GAP_X = 28;
+const GAP_ROW = 20;
+/** Space between one band and the next — where the edges run. */
+const GAP_BAND = 56;
+/** Inner padding of a band, and the strip its label sits in. */
+const PAD = 20;
+const TITLE = 22;
+/** The band a node belongs to: its layer, or none (drawn last, as Unassigned). */
+const UNASSIGNED = Number.POSITIVE_INFINITY;
+const layerOf = (node) => node.layer ?? UNASSIGNED;
+/** How an edge sits against the layering, from the two layers the host gave. */
+export function deriveConformance(from, to) {
+    if (from === undefined || to === undefined)
+        return undefined;
+    if (to === from)
+        return 'level';
+    if (to < from)
+        return 'up';
+    return to - from === 1 ? 'down' : 'skip';
+}
+/** Nodes grouped by layer, in band order (Unassigned last). */
+function bandsOf(model) {
+    const bands = new Map();
+    for (const node of model.nodes) {
+        const key = layerOf(node);
+        bands.set(key, [...(bands.get(key) ?? []), node]);
+    }
+    return [...bands.entries()].sort(([a], [b]) => a - b);
+}
+/** Undirected neighbour ids per node — the barycenter reads both directions. */
+function neighbours(model) {
+    const near = new Map();
+    const link = (a, b) => near.set(a, [...(near.get(a) ?? []), b]);
+    for (const e of model.edges) {
+        if (e.source === e.target)
+            continue;
+        link(e.source, e.target);
+        link(e.target, e.source);
+    }
+    return near;
+}
+/**
+ * Order each band: the first alphabetically, every later one by the mean index of its
+ * neighbours in the band above (alphabetical among nodes with none there).
+ */
+function order(bands, near) {
+    const ordered = [];
+    let above = new Map();
+    for (const [, nodes] of bands) {
+        const centre = (n) => {
+            const hits = (near.get(n.id) ?? []).map((id) => above.get(id)).filter((i) => i !== undefined);
+            return hits.length > 0 ? hits.reduce((s, i) => s + i, 0) / hits.length : Number.POSITIVE_INFINITY;
+        };
+        const band = [...nodes].sort((a, b) => centre(a) - centre(b) || a.label.localeCompare(b.label));
+        ordered.push(band);
+        above = new Map(band.map((n, i) => [n.id, i]));
+    }
+    return ordered;
+}
+const chunk = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, i) => items.slice(i * size, (i + 1) * size));
+const rowWidth = (count) => count * CARD_W + Math.max(0, count - 1) * GAP_X;
+/** Place one band's cards, row by row, centred in the shared width. Returns the band height. */
+function placeBand(band, cards, top, width) {
+    let y = top + TITLE + PAD;
+    const rows = chunk(band, PER_ROW);
+    rows.forEach((row, r) => {
+        let x = (width - rowWidth(row.length)) / 2;
+        const tallest = Math.max(...row.map((n) => cards[n.id].h));
+        for (const node of row) {
+            Object.assign(cards[node.id], { x, y });
+            x += CARD_W + GAP_X;
+        }
+        y += tallest + (r < rows.length - 1 ? GAP_ROW : 0);
+    });
+    return y + PAD - top;
+}
+/** The host's name for a layer, else the locale's — "Layer 2", "Unassigned". */
+const labelFor = (layer, labels) => layer === UNASSIGNED ? say('layerUnassigned') : (labels?.[layer] ?? say('layer', { n: layer }));
+/** A vertical S: out of the bottom of a card above, into the top of a card below (or reverse). */
+function route(edge, i, cards, conformance) {
+    const a = cards[edge.source];
+    const b = cards[edge.target];
+    const downward = b.y >= a.y + a.h;
+    const x1 = a.x + a.w / 2;
+    const x2 = b.x + b.w / 2;
+    const y1 = downward ? a.y + a.h : a.y;
+    const y2 = downward ? b.y : b.y + b.h;
+    const mid = (y1 + y2) / 2;
+    return {
+        i,
+        id: edge.id,
+        fromKey: edge.source,
+        toKey: edge.target,
+        kind: edge.kind,
+        relation: edge.relation,
+        ...carried(edge),
+        ...(conformance ? { conformance } : {}),
+        self: false,
+        x1,
+        y1,
+        x2,
+        y2,
+        s1: 1,
+        s2: 1,
+        path: `M ${x1} ${y1} C ${x1} ${mid}, ${x2} ${mid}, ${x2} ${y2}`
+    };
+}
+function edgesFor(model, cards, showEdges) {
+    const routed = [];
+    model.edges.forEach((edge, i) => {
+        if (edge.source === edge.target || !cards[edge.source] || !cards[edge.target])
+            return;
+        const conformance = edge.conformance ??
+            deriveConformance(cards[edge.source].node.layer, cards[edge.target].node.layer);
+        const routedEdge = route(edge, i, cards, conformance);
+        if (keepsEdge(showEdges, routedEdge))
+            routed.push(routedEdge);
+    });
+    return routed;
+}
+/** Stack the bands top to bottom, each a full-width labelled box around its cards. */
+function placeBands(ordered, layerKeys, cards, { width, labels }) {
+    const clusters = [];
+    let top = 0;
+    ordered.forEach((band, i) => {
+        const h = placeBand(band, cards, top, width);
+        clusters.push({
+            name: labelFor(layerKeys[i], labels),
+            caption: String(band.length),
+            list: band,
+            count: band.length,
+            groupIndex: i,
+            depth: 0,
+            x: 0,
+            y: top,
+            w: width,
+            h
+        });
+        top += h + GAP_BAND;
+    });
+    return { clusters, height: top - GAP_BAND };
+}
+/** Host-assigned layers as horizontal bands, layer 0 at the top. */
+export const layers = (model, options) => {
+    warnUnknownOptions(options, 'layers');
+    if (model.nodes.length === 0)
+        return { clusters: [], cards: {}, edges: [], size: { w: 0, h: 0 } };
+    const cards = buildCards(model.nodes, options.density ?? 'names', { expanded: options.expanded });
+    const bands = bandsOf(model);
+    const ordered = order(bands, neighbours(model));
+    const width = rowWidth(Math.min(PER_ROW, Math.max(...ordered.map((b) => b.length)))) + PAD * 2;
+    const { clusters, height } = placeBands(ordered, bands.map(([layer]) => layer), cards, { width, labels: options.layerLabels });
+    return {
+        clusters,
+        cards,
+        edges: edgesFor(model, cards, options.showEdges ?? 'all'),
+        size: { w: width, h: height }
+    };
+};

package/dist/layout/matrix.d.ts

@@ -0,0 +1,50 @@
+import type { NodeAxis } from './types.js';
+import type { GraphModel } from '../types.js';
+export type MatrixCell = {
+    /** Index into `order` of the dependent (the edge's source). */
+    row: number;
+    /** Index into `order` of the dependency (the edge's target). */
+    col: number;
+    source: string;
+    target: string;
+    /** Edges folded into this cell — two FKs, a read and a write — each counted by its weight. */
+    count: number;
+    /** Against the grain: a cycle or a layer reaching up. */
+    above: boolean;
+};
+export type MatrixBlock = {
+    name: string;
+    start: number;
+    end: number;
+};
+export type Matrix = {
+    /** Node ids, providers first. Row i and column i are the same node. */
+    order: string[];
+    labels: string[];
+    /** Each node's group key on the grouping axis, parallel to `order` ('' when ungrouped). */
+    groups: string[];
+    cells: MatrixCell[];
+    /** Contiguous group runs along the diagonal. Empty when not grouping. */
+    blocks: MatrixBlock[];
+    /** Cells above the diagonal. */
+    above: number;
+    /** The largest `count`, for scaling cell intensity. */
+    maxCount: number;
+};
+export type MatrixOptions = {
+    /** Keep each group contiguous and outline it on the diagonal. Omit for one flat order. */
+    groupBy?: NodeAxis;
+};
+export declare function buildMatrix(model: GraphModel, options?: MatrixOptions): Matrix;
+/** The matrix's frame: a label gutter sized by the longest name (by length, not the DOM —
+ *  deterministic, like every layout here), and the canvas around `n` cells of `cell` px. */
+export declare function matrixFrame(matrix: Pick<Matrix, 'labels' | 'order'>, cell: number): {
+    labelW: number;
+    n: number;
+    width: number;
+    height: number;
+};
+/** A cell on the selected node's row or column is highlighted; nothing is without a selection. */
+export declare const cellState: (selected: string | null, source: string, target: string) => "highlight" | undefined;
+/** The matrix's accessible name: what it holds, from the locale. */
+export declare function matrixLabel(nodes: number, dependencies: number, above: number): string;

package/dist/layout/matrix.js

@@ -0,0 +1,110 @@
+/* The dependency structure matrix (DSM): every node is both a row and a column, and a cell at
+ * (row, col) says "row depends on col".
+ *
+ * Its strength is the ORDER. Providers come first, so in a layered architecture every
+ * dependency points up-and-left and the whole matrix is lower-triangular. A mark ABOVE the
+ * diagonal is then a dependency against the grain — a cycle, or a layer that reaches up —
+ * and it is visible at a glance at sizes where a node-link drawing is a hairball.
+ *
+ * The order reuses `flow`'s ranking (longest path, DFS cycle breaking), reversed: `rank` puts
+ * a target in a later column than its source, and a DSM wants the target FIRST. Grouping keeps
+ * each group contiguous, ordered by where its first member ranks, so a module's block sits on
+ * the diagonal and a cross-module dependency against the grain lands above it.
+ *
+ * Pure and DOM-free, like every layout.
+ */
+import { counted, say } from '../messages.js';
+import { rank } from './rank.js';
+const axisOf = (node, axis) => (axis === 'kind' ? node.kind : node.group) ?? '';
+/** Node ids, providers first; with `groupBy`, each group contiguous in first-ranked order. */
+function orderNodes(model, groupBy) {
+    const { ranks } = rank(model);
+    // `rank` places every node, so each lookup hits; carrying the model index alongside the
+    // rank keeps ties in model order without a second map.
+    const byRank = model.nodes
+        .map((node, i) => ({ node, i, r: ranks.get(node.id) }))
+        .sort((a, b) => b.r - a.r || a.i - b.i)
+        .map((entry) => entry.node);
+    if (!groupBy)
+        return byRank;
+    const runs = new Map();
+    for (const node of byRank) {
+        const key = axisOf(node, groupBy);
+        const run = runs.get(key) ?? [];
+        run.push(node);
+        runs.set(key, run);
+    }
+    return [...runs.values()].flat();
+}
+function blocksOf(groups) {
+    const blocks = [];
+    groups.forEach((name, i) => {
+        const last = blocks[blocks.length - 1];
+        if (last && last.name === name)
+            last.end = i;
+        else
+            blocks.push({ name, start: i, end: i });
+    });
+    return blocks;
+}
+/** One cell per (dependent, dependency) pair, parallel edges folded into its count. */
+function collectCells(model, index) {
+    const cells = new Map();
+    for (const edge of model.edges) {
+        const row = index.get(edge.source);
+        const col = index.get(edge.target);
+        if (row === undefined || col === undefined || row === col)
+            continue;
+        const key = `${row}:${col}`;
+        // A weighted edge already IS a count — an import list aggregated to components says
+        // "7 imports" once rather than repeating the edge seven times.
+        const n = edge.weight ?? 1;
+        const cell = cells.get(key);
+        if (cell)
+            cell.count += n;
+        else
+            cells.set(key, {
+                row,
+                col,
+                source: edge.source,
+                target: edge.target,
+                count: n,
+                above: col > row
+            });
+    }
+    return [...cells.values()].sort((a, b) => a.row - b.row || a.col - b.col);
+}
+export function buildMatrix(model, options = {}) {
+    const nodes = orderNodes(model, options.groupBy);
+    const index = new Map(nodes.map((n, i) => [n.id, i]));
+    const cells = collectCells(model, index);
+    const groups = nodes.map((n) => (options.groupBy ? axisOf(n, options.groupBy) : ''));
+    return {
+        order: nodes.map((n) => n.id),
+        labels: nodes.map((n) => n.label),
+        groups,
+        cells,
+        blocks: options.groupBy ? blocksOf(groups) : [],
+        above: cells.filter((c) => c.above).length,
+        maxCount: Math.max(0, ...cells.map((c) => c.count))
+    };
+}
+/** The matrix's frame: a label gutter sized by the longest name (by length, not the DOM —
+ *  deterministic, like every layout here), and the canvas around `n` cells of `cell` px. */
+export function matrixFrame(matrix, cell) {
+    const longest = Math.max(0, ...matrix.labels.map((label) => label.length));
+    const labelW = Math.min(220, Math.max(48, longest * 6.5 + 14));
+    const n = matrix.order.length;
+    const side = labelW + n * cell + 8;
+    return { labelW, n, width: side, height: side };
+}
+/** A cell on the selected node's row or column is highlighted; nothing is without a selection. */
+export const cellState = (selected, source, target) => selected && (source === selected || target === selected) ? 'highlight' : undefined;
+/** The matrix's accessible name: what it holds, from the locale. */
+export function matrixLabel(nodes, dependencies, above) {
+    return say('matrix', {
+        nodes: counted(nodes, 'nodeOne', 'nodeMany'),
+        dependencies: counted(dependencies, 'dependencyOne', 'dependencyMany'),
+        above
+    });
+}

package/dist/layout/neighborhood.js

@@ -115,12 +115,17 @@ function buildNeighbourCards(model, neighbours, expanded) {
  * Place every ring, size the canvas, and name the columns.
  *
  * An EMPTY ring costs no width: a depth-2 request on a graph with nothing at depth 2 must not
- * leave a gap where that column would have been, so the width is measured from the rightmost
- * column that actually exists rather than from the depth asked for.
+ * leave a gap where that column would have been, so the width is measured from the deepest
+ * column that actually exists rather than from the depth asked for. An empty SIDE is
+ * different (#170): the focus is centred, so the shallower side reserves the deeper side's
+ * columns — otherwise "centred" would only hold for a node with neighbours both ways.
  */
 function arrange(built, cards, ctx) {
     const occupied = built.filter((r) => r.ids.length > 0);
-    const { focusX, xFor } = geometry(occupied);
+    // The same edge room on BOTH sides — a self-loop's bow plus a hairline — so the canvas
+    // stays symmetric about the focus.
+    const edge = (ctx.hasLoop ? LOOP_W : 0) + 2;
+    const { focusX, xFor } = geometry(occupied, edge);
     const focusCard = cards[ctx.focus.id];
     const height = placeRings(occupied, cards, { focusCard, focusX, xFor });
     const columns = buildColumns(occupied, {
@@ -129,7 +134,9 @@ function arrange(built, cards, ctx) {
         xFor,
         dependency: ctx.dependency
     });
-    const width = xFor('out', furthest(occupied, 'out')) + CARD_W + (ctx.hasLoop ? LOOP_W : 0) + 4;
+    // Symmetric about the focus (#170): as much room right of it as left, so the focus card's
+    // centre IS the canvas's centre whichever side is empty or deeper.
+    const width = focusX * 2 + CARD_W;
     return { columns, size: { w: width, h: height } };
 }
 /**
@@ -161,11 +168,13 @@ function drawableIn(model, cards) {
 }
 /**
  * Where each ring sits. Ring d on the `in` side is d steps left of the focus; on the `out`
- * side, d steps right. The focus is pushed right by however deep the inbound side goes.
+ * side, d steps right. The focus sits past `edge` and as many columns as the DEEPER side
+ * needs, so both sides get the same room and the focus is the centre.
  */
-function geometry(occupied) {
+function geometry(occupied, edge) {
     const columnStep = CARD_W + COL_GAP;
-    const focusX = furthest(occupied, 'in') * columnStep;
+    const reach = Math.max(furthest(occupied, 'in'), furthest(occupied, 'out'));
+    const focusX = edge + reach * columnStep;
     return {
         focusX,
         xFor: (side, d) => (side === 'in' ? focusX - d * columnStep : focusX + d * columnStep)

package/dist/layout/options.d.ts

@@ -4,7 +4,7 @@ import type { LayoutOptions } from './types.js';
  * missed here would warn about a legitimate option, which is worse than the silence this
  * exists to fix. `spec/options.spec.ts` compares the two.
  */
-export declare const LAYOUT_OPTION_KEYS: readonly ["density", "arrange", "edgeStyle", "focus", "expanded", "groupBy", "nestBy", "sizeBy", "sizeScale", "depth", "focusPath", "levels", "radialMode", "root", "bundleTension"];
+export declare const LAYOUT_OPTION_KEYS: readonly ["density", "arrange", "edgeStyle", "focus", "expanded", "groupBy", "nestBy", "sizeBy", "sizeScale", "depth", "focusPath", "levels", "radialMode", "root", "bundleTension", "showEdges", "layerLabels", "widthBy", "heightBy", "colorBy", "above", "shadeBy"];
 /**
  * Which options have an EFFECT under each built-in layout.
  *

package/dist/layout/options.js

@@ -18,7 +18,14 @@ export const LAYOUT_OPTION_KEYS = [
     'levels',
     'radialMode',
     'root',
-    'bundleTension'
+    'bundleTension',
+    'showEdges',
+    'layerLabels',
+    'widthBy',
+    'heightBy',
+    'colorBy',
+    'above',
+    'shadeBy'
 ];
 /**
  * Which options have an EFFECT under each built-in layout.
@@ -39,14 +46,20 @@ export const LAYOUT_OPTION_KEYS = [
  *     its own purpose.
  */
 export const LAYOUT_OPTIONS = {
+    // No edgeStyle: an arc is the only shape that keeps one axis readable.
+    arcs: ['showEdges', 'above'],
     cluster: ['density', 'arrange', 'edgeStyle', 'expanded', 'groupBy', 'nestBy'],
     flow: ['density', 'edgeStyle', 'expanded'],
+    // No edgeStyle: a layered edge is always a vertical S, built by the layout itself.
+    layers: ['density', 'expanded', 'showEdges', 'layerLabels'],
     neighborhood: ['edgeStyle', 'expanded', 'focus', 'depth'],
     points: ['edgeStyle', 'sizeBy', 'sizeScale'],
+    // No edgeStyle: the tree's links are elbows the layout draws itself.
+    polymetric: ['widthBy', 'heightBy', 'colorBy'],
     radial: ['edgeStyle', 'sizeBy', 'sizeScale', 'radialMode', 'levels', 'root'],
-    sunburst: ['sizeBy', 'focusPath', 'levels'],
+    sunburst: ['sizeBy', 'shadeBy', 'focusPath', 'levels'],
     structure: ['sizeBy', 'sizeScale', 'focusPath', 'levels', 'bundleTension'],
-    world: ['sizeBy', 'focusPath', 'levels']
+    world: ['sizeBy', 'shadeBy', 'focusPath', 'levels']
 };
 /**
  * Layouts that draw a node as a DOT rather than a card.

package/dist/layout/percentile.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The 95th-percentile cap of the present, positive values — 1 when there are none.
+ *
+ * Code metrics are long-tailed: one file with ten times the functions, one import pair with
+ * fifty times the count. Scaling to the maximum shrinks everything else to the minimum, so a
+ * channel scales to this instead and a value past it clamps (#168, #169).
+ */
+export declare function capOf(values: (number | undefined)[]): number;

package/dist/layout/percentile.js

@@ -0,0 +1,13 @@
+/**
+ * The 95th-percentile cap of the present, positive values — 1 when there are none.
+ *
+ * Code metrics are long-tailed: one file with ten times the functions, one import pair with
+ * fifty times the count. Scaling to the maximum shrinks everything else to the minimum, so a
+ * channel scales to this instead and a value past it clamps (#168, #169).
+ */
+export function capOf(values) {
+    const sorted = values.filter((v) => v !== undefined && v > 0).sort((a, b) => a - b);
+    if (sorted.length === 0)
+        return 1;
+    return sorted[Math.min(sorted.length - 1, Math.ceil(0.95 * sorted.length) - 1)];
+}

package/dist/layout/polymetric.d.ts

@@ -0,0 +1,3 @@
+import type { LayoutFn } from './types.js';
+/** The containment tree with each leaf's width, height and shade bound to three measures. */
+export declare const polymetric: LayoutFn;