react-x11 2.47.4 → 2.47.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-x11",
-  "version": "2.47.4",
+  "version": "2.47.5",
   "description": "react renderer with X11 as a target",
   "main": "./src/index.js",
   "files": [

package/src/nodes/window/floors.js

@@ -333,7 +333,8 @@ export function dirtyOutside(node, boundaries, paths) {
  * Undefined where it cannot be summed: a child with no extent on hand, a
  * negative margin (the boxes would overlap, and the last would not have to
  * be the lowest), or nothing in flow at all — a leaf's answer, which is
- * `contentSpan`'s to give.
+ * `contentSpan`'s to give. All but the first are the column's own, and a
+ * spine never sums a column that has them (`columnSums`).
  */
 export function columnHeightSpan(node) {
   const yoga = node.yoga;
@@ -363,6 +364,30 @@ export function columnHeightSpan(node) {
   );
 }
 
+/**
+ * Whether `columnHeightSpan` has an answer for this column once its children
+ * carry extents: everything else it asks — something in flow, margins down
+ * that are lengths and pull no box over the one before it, a gap that is a
+ * length — asked ahead of the measurement, from the same readings.
+ *
+ * A spine asks it before it sums a column (`isSummableColumn`), because once
+ * the measurement is under way a sum with no answer has nowhere to go: it is
+ * written as the column's extent, an extent of none writes the style's own
+ * minimum, and the column — and every column summed above it — lost its
+ * floor to a label that changed beside a block with `marginTop: -4`.
+ */
+export function columnSums(node) {
+  if (columnGap(node) === undefined) return false;
+  let count = 0;
+  for (const child of node.children) {
+    if (!inFlow(child)) continue;
+    const { top, bottom } = marginsDown(child);
+    if (!(top >= 0 && bottom >= 0)) return false;
+    count += 1;
+  }
+  return count !== 0;
+}
+
 /**
  * `marginDown` for both edges of a box, kept on the box with the style object
  * it was read under. A margin reaches yoga only from the style

package/src/nodes/window/spine.js

@@ -36,6 +36,7 @@
 // length — is not a spine, and the tree is measured whole.
 
 import {
+  columnSums,
   declaresOwnMinimum,
   inFlow,
   mainAxisOf,
@@ -74,7 +75,9 @@ const PADDINGS = [
  * main axis without wrapping, and with a height that is its content's —
  * nothing named on the height axis (`declaresOwnMinimum`), so neither a
  * size, a floor, a ceiling nor a clip stands between its children and its
- * extent.
+ * extent. And one the sum has an answer for (`columnSums`): a column with a
+ * block pulled up over the one before it is measured, as a root, rather
+ * than summed into no extent and no floor.
  */
 export function isSummableColumn(node) {
   const style = node.style;
@@ -86,7 +89,8 @@ export function isSummableColumn(node) {
     mainAxisOf(node) === 'height' &&
     style.flexDirection !== 'column-reverse' &&
     (style.flexWrap == null || style.flexWrap === 'nowrap') &&
-    !declaresOwnMinimum(node, 'height')
+    !declaresOwnMinimum(node, 'height') &&
+    columnSums(node)
   );
 }
 
@@ -129,6 +133,17 @@ export function spineScope(root, sources, listOnly) {
   const spine = new Set();
   const stops = new Set();
   const offered = new OfferedWidths(root);
+  // asked once a column: a dozen rows that arrive in one column of a
+  // thousand ask it of that column a dozen times (`columnSums`)
+  const summable = new Map();
+  const sums = (column) => {
+    let answer = summable.get(column);
+    if (answer === undefined) {
+      answer = isSummableColumn(column);
+      summable.set(column, answer);
+    }
+    return answer;
+  };
   for (const source of sources) {
     const list = listOnly(source);
     // the way up to where the change stops mattering
@@ -148,7 +163,7 @@ export function spineScope(root, sources, listOnly) {
     let top = -1;
     for (let i = path.length - 1; i >= 0; i--) {
       const summed = i > 0 || list;
-      if (!summed || !isSummableColumn(path[i])) {
+      if (!summed || !sums(path[i])) {
         top = i;
         break;
       }
@@ -379,6 +394,9 @@ function rootWidths(node, offered, stop) {
   if (!stretched(node)) return null;
   if (MARGINS.some((key) => typeof style[key] === 'string')) return null;
   if (PADDINGS.some((key) => typeof style[key] === 'string')) return null;
+  // …nor a gap that is a share of something: laid out alone, it is a share
+  // of something else
+  if (typeof (style.rowGap ?? style.gap) === 'string') return null;
   return offered.in(parent, stop);
 }