postext 0.3.38 → 0.3.39

package/dist/pipeline/build.js

@@ -233,6 +233,13 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
     /** Offset a resolved resource block's caption/table geometry from
      *  block-relative to absolute page coordinates (mirrors inline placement). */
     const offsetResourceBlockToAbsolute = (rb, ox, oy) => {
+        // A rotated block keeps its geometry in the upright frame; only the
+        // frame's origin moves on the page.
+        if (rb.rotation) {
+            rb.rotation.originX += ox;
+            rb.rotation.originY += oy;
+            return;
+        }
         for (const ln of rb.captionLines) {
             ln.bbox.x += ox;
             ln.bbox.y += oy;
@@ -268,7 +275,8 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             }
         }
     };
-    const layoutFloat = (resourceId, width, slice) => {
+    const rotationKey = (rotated) => rotated ? `:${rotated.direction}${rotated.length.toFixed(2)}` : '';
+    const layoutFloat = (resourceId, width, slice, rotated) => {
         const resource = resourceById.get(resourceId);
         if (!resource)
             return null;
@@ -282,8 +290,15 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             resourceTypes,
             resources,
             ...(slice ? { slice } : {}),
+            ...(rotated ? { rotate: rotated.direction, rotatedLength: rotated.length } : {}),
         });
     };
+    /** The rotation of a pending float on a band whose columns keep `avail`
+     *  px: the upright frame is as long as the grid multiple within that
+     *  room, less the float gap, so the band it takes is `avail` at most. */
+    const rotationFor = (f, avail) => f.rotate
+        ? { direction: f.rotate, length: Math.max(1, Math.floor((avail + 0.01) / baselineGrid) * baselineGrid - floatGapPx) }
+        : undefined;
     /** Row count of a table resource (0 for anything else). */
     const tableRowCount = (resourceId) => resourceById.get(resourceId)?.table?.model.rows.length ?? 0;
     /** The slice a pending float stands for: the whole resource, or — for the
@@ -295,26 +310,31 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
     const sliceKey = (slice) => slice ? `:${slice.startRow}-${slice.endRow}${slice.continues ? '+' : ''}` : '';
     /** Row metrics of a table float laid out in full at a width, memoised. */
     const tableMetricsMemo = new Map();
-    const tableMetrics = (resourceId, width) => {
-        const key = `${resourceId}:${width.toFixed(2)}`;
+    const tableMetrics = (resourceId, width, rotated) => {
+        const key = `${resourceId}:${width.toFixed(2)}${rotationKey(rotated)}`;
         const memo = tableMetricsMemo.get(key);
         if (memo !== undefined)
             return memo;
-        const m = layoutFloat(resourceId, width)?.tableRows ?? null;
+        const m = layoutFloat(resourceId, width, undefined, rotated)?.tableRows ?? null;
         tableMetricsMemo.set(key, m);
         return m;
     };
     /** Height (and caption baseline) of a float at a given width, memoised —
      *  fit checks run for every pending float on every loop iteration. */
     const floatMeasureMemo = new Map();
-    const measureFloat = (resourceId, width, slice) => {
-        const key = `${resourceId}:${width.toFixed(2)}${sliceKey(slice)}`;
+    const measureFloat = (resourceId, width, slice, rotated) => {
+        const key = `${resourceId}:${width.toFixed(2)}${sliceKey(slice)}${rotationKey(rotated)}`;
         const memo = floatMeasureMemo.get(key);
         if (memo !== undefined)
             return memo;
-        const laid = layoutFloat(resourceId, width, slice);
+        const laid = layoutFloat(resourceId, width, slice, rotated);
         let m = null;
-        if (laid) {
+        if (laid && laid.block.rotation) {
+            // A rotated block takes its band whole: no caption baseline to align,
+            // and its upright height is what must fit the band's width.
+            m = { height: laid.totalHeight, rotatedWidth: laid.block.rotation.height };
+        }
+        else if (laid) {
             // A bottom band aligns the float's LAST text line to the grid: the
             // caption's (or the note's) last line when it sits under the body. A
             // caption set above the body (caption bars) leaves the body's bottom
@@ -338,8 +358,11 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
     };
     /** Measure + build a float block at horizontal offset `x` (y = 0), or null
      *  when the resource id is unknown. Caller offsets it to its final `y`. */
-    const buildFloatBlock = (resourceId, x, width, slice) => {
-        const laid = layoutFloat(resourceId, width, slice);
+    const buildFloatBlock = (resourceId, x, width, slice, rotated, 
+    /** A rotated block sits flush to the band's right edge (the spine of a
+     *  verso page) instead of its left. */
+    flushEnd = false) => {
+        const laid = layoutFloat(resourceId, width, slice, rotated);
         if (!laid)
             return null;
         const { block: rb, totalHeight } = laid;
@@ -350,9 +373,23 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         blk.snappedToGrid = false;
         blk.bbox = createBoundingBox(x, 0, width, totalHeight);
         blk.lines = [];
-        offsetResourceBlockToAbsolute(rb, x, 0);
+        if (rb.rotation) {
+            // The upright frame's origin: for a counter-clockwise turn the frame's
+            // top-left lands at the bottom-left of the block, for a clockwise one
+            // at its top-right (see `resourceBlockToPage`).
+            const used = Math.min(rb.rotation.height, width);
+            const left = x + (flushEnd ? Math.max(0, width - used) : 0);
+            rb.rotation.originX = rb.rotation.direction === 'ccw' ? left : left + used;
+            rb.rotation.originY = rb.rotation.direction === 'ccw' ? totalHeight : 0;
+        }
+        else {
+            offsetResourceBlockToAbsolute(rb, x, 0);
+        }
         return { block: blk, height: totalHeight };
     };
+    /** Whether a rotated float on `page` sits flush to the band's right edge:
+     *  with mirrored margins the spine of a verso (even-numbered) page. */
+    const rotatedFlushEnd = (page) => !!resolved.page.margins.mirror && (page.index + pageIndexOffset) % 2 === 1;
     /** Float bands reserved per column in this pass (the fresh-page flush
      *  sends single-column floats to the least reserved column). */
     const floatReserved = new Map();
@@ -386,14 +423,14 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
      * (current-page) mode nothing is forced: `'none'` when not even the
      * smallest slice fits the slot.
      */
-    const splitTableFloat = (f, width, position, targetCols, contentArea, avail, mode) => {
+    const splitTableFloat = (f, width, position, targetCols, contentArea, avail, mode, rotated) => {
         const rowCount = tableRowCount(f.resourceId);
         if (rowCount === 0)
             return null;
         const overflow = resolved.tableStyle.overflow;
         if (overflow === 'hide')
             return 'skip';
-        const metrics = tableMetrics(f.resourceId, width);
+        const metrics = tableMetrics(f.resourceId, width, rotated);
         if (!metrics)
             return null;
         const startRow = f.startRow ?? 0;
@@ -402,14 +439,16 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             return null;
         // Overhead of a continuing slice at this width — caption, gaps, marker —
         // from a one-row probe; the row heights come from the metrics.
-        const probe = layoutFloat(f.resourceId, width, { startRow, endRow: firstBody + 1, continues: true });
+        const probe = layoutFloat(f.resourceId, width, { startRow, endRow: firstBody + 1, continues: true }, rotated);
         if (!probe)
             return null;
-        const overhead = probe.totalHeight - probe.block.bodyRect.height;
+        // A rotated table's rows run across the page: the room for them is
+        // the band's width, less the upright overhead.
+        const overhead = (probe.block.rotation ? probe.block.rotation.height : probe.totalHeight) - probe.block.bodyRect.height;
         // A top band rounds up to the grid: the tallest float it holds within
         // `avail` is the grid multiple below it, less the gap.
         const hMax = Math.floor((avail + 0.01) / baselineGrid) * baselineGrid - floatGapPx;
-        let end = planTableSlice(metrics, startRow, hMax - overhead);
+        let end = planTableSlice(metrics, startRow, (rotated ? width : hMax) - overhead);
         const floor = firstBody + 1;
         if (end < floor) {
             // Nothing fits. A fresh page carries the smallest slice anyway (it
@@ -432,9 +471,11 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
                 end = e;
         }
         const fits = (slice) => {
-            const measure = measureFloat(f.resourceId, width, slice);
+            const measure = measureFloat(f.resourceId, width, slice, rotated);
             if (!measure)
                 return true;
+            if (rotated)
+                return (measure.rotatedWidth ?? 0) <= width + 0.01;
             const { need } = measureFloatBand(position, measure, targetCols, contentArea, baselineGrid, floatGapPx, (c) => trueBottom(c, uncappedBottoms));
             return need <= avail + 0.01;
         };
@@ -478,7 +519,8 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         const width = pageSpan ? page.contentArea.width : first.bbox.width;
         const xLeft = pageSpan ? page.contentArea.x : first.bbox.x;
         const slice = sliceOf(f);
-        const measure = measureFloat(f.resourceId, width, slice);
+        const rotated = rotationFor(f, Math.min(...targetCols.map((c) => c.availableHeight)));
+        const measure = measureFloat(f.resourceId, width, slice, rotated);
         if (!measure)
             return null;
         // A bottom band normally anchors to the column's true foot (under a
@@ -487,7 +529,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         // and the box follows both.
         const bottomOf = (c) => anchorToCap ? c.bbox.y + c.bbox.height : trueBottom(c, uncappedBottoms);
         const { need, y } = measureFloatBand(position, measure, targetCols, page.contentArea, baselineGrid, floatGapPx, bottomOf);
-        return { need, y, measure, slice, width, xLeft };
+        return { need, y, measure, slice, width, xLeft, rotated };
     };
     /** Free height `col` keeps for the flow once a float band `probe` is
      *  reserved in it at `position` (mirrors the reservation arithmetic of
@@ -506,11 +548,13 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         const probe = probeFloatBand(page, f, targetCols, position, pageSpan, anchorToCap);
         if (!probe)
             return 'skip';
-        const { width, xLeft } = probe;
+        const { width, xLeft, rotated } = probe;
         let { slice, measure, need, y } = probe;
         let rest;
         /** The float was cut to this slot (a table slice). */
         let cut = false;
+        /** A rotated block wider than the band (its upright height). */
+        const tooWide = (m) => m.rotatedWidth !== undefined && m.rotatedWidth > width + 0.01;
         if (mode === 'fresh') {
             let minAvail = Infinity;
             let anyReserved = false;
@@ -522,16 +566,17 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             }
             if (need > minAvail - minTextPx && anyReserved)
                 return 'defer';
-            if (need > minAvail + 0.01) {
-                // Dominating the band: a table is cut to it.
-                const split = splitTableFloat(f, width, position, targetCols, page.contentArea, minAvail, 'fresh');
+            if (need > minAvail + 0.01 || tooWide(measure)) {
+                // Dominating the band: a table is cut to it (a rotated table, to
+                // the band's width).
+                const split = splitTableFloat(f, width, position, targetCols, page.contentArea, minAvail, 'fresh', rotated);
                 if (split === 'skip')
                     return 'skip';
                 if (split && split !== 'none') {
                     slice = split.slice;
                     rest = split.rest;
                     cut = true;
-                    const m = measureFloat(f.resourceId, width, slice);
+                    const m = measureFloat(f.resourceId, width, slice, rotated);
                     if (!m)
                         return 'skip';
                     measure = m;
@@ -540,6 +585,11 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
             }
         }
         else {
+            // A rotated block takes a page of its own: it never shares the
+            // current page's foot, and waits for a fresh page to be cut to when
+            // too wide.
+            if (f.rotate || tooWide(measure))
+                return 'defer';
             for (const c of targetCols) {
                 if (position === 'bottom' && uncappedBottoms.has(c) && !anchorToCap) {
                     // Trailing cap: the band must lie entirely below the level cut.
@@ -585,7 +635,7 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         if (rest) {
             rest = { ...rest, notBefore: { pageIndex: page.index, columnIndex: targetCols[targetCols.length - 1].index } };
         }
-        const built = buildFloatBlock(f.resourceId, xLeft, width, slice);
+        const built = buildFloatBlock(f.resourceId, xLeft, width, slice, rotated, rotated ? rotatedFlushEnd(page) : false);
         if (!built)
             return 'skip';
         for (const col of targetCols) {
@@ -653,7 +703,8 @@ export function buildDocumentPass(content, config, cache, options, hints = {}) {
         }
         return false;
     };
-    const positionsFor = (f) => f.position === 'auto' ? ['top', 'bottom'] : [f.position];
+    /** A rotated float takes its page from the top. */
+    const positionsFor = (f) => f.rotate ? ['top'] : f.position === 'auto' ? ['top', 'bottom'] : [f.position];
     /** Reserve top/bottom bands on a freshly opened page and position as many
      *  pending floats as fit, shrinking the affected columns so body text flows
      *  around them. Full-width (page-span) floats reserve the outermost bands