postext 1.9.2 → 1.11.0

package/dist/pipeline/build.js

@@ -23,7 +23,7 @@ import { chooseParagraphSplit } from './orphanWidow';
 import { applyStyleAttrs, computePageMetrics, pageMirrored, sheetRectToFlow, isMarkerBlock, nextNonMarkerBlock, spaceLinesAfter, prevNonMarkerBlock, rollbackTrailingBlocks, } from './buildHelpers';
 import { measureContentBlock } from './measureContentBlock';
 import { planParagraphContainers } from './paragraphContainers';
-import { appendChapterEndNotes, footnoteIdsOfLines, footnoteParagraphStyle, noteContentBlock, numberFootnotes, splitFootnoteDefinitions, withFootnoteStyle, } from './footnotes';
+import { appendChapterEndNotes, footnoteIdsOfLines, footnoteParagraphStyle, noteContentBlock, numberFootnotes, numberFootnotesByPlacement, sameFootnoteNumbers, splitFootnoteDefinitions, withFootnoteStyle, } from './footnotes';
 import { planParts, derivePartMeasureContext } from './parts';
 import { layoutCallout, offsetCalloutToAbsolute, pickCalloutStyle, planCallouts, resolveCalloutAttrs, } from './calloutLayout';
 import { layoutResourceBlock, planTableSlice } from './resourceLayout';
@@ -273,10 +273,19 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // come back as paragraphs after each chapter's last block.
     const footnoteSplit = splitFootnoteDefinitions(headingMarksFor(parseMarkdownMemo(markdownBody), resolved));
     const footnoteDefs = footnoteSplit.defs;
-    const footnoteNumbering = numberFootnotes(footnoteSplit.blocks, resolved.footnotes.numbering, resolved.footnotes.numbering === 'document' ? Math.max(0, Math.floor(continuation?.footnoteNumber ?? 0)) : 0);
+    // Numbered by page or column (`numbering: 'page'`), a note takes the
+    // number the previous build gave it where it landed; the first build
+    // numbers by chapter (see `buildDocumentNumbered`).
+    const footnoteNumbering = numberFootnotes(footnoteSplit.blocks, resolved.footnotes.numbering, resolved.footnotes.numbering === 'document' ? Math.max(0, Math.floor(continuation?.footnoteNumber ?? 0)) : 0, resolved.footnotes.numberFormat);
+    if (hints.footnoteNumbers) {
+        for (const [id, number] of hints.footnoteNumbers) {
+            if (footnoteNumbering.numbers.has(id))
+                footnoteNumbering.numbers.set(id, number);
+        }
+    }
     const chapterEndNotes = resolved.footnotes.placement === 'chapterEnd' && footnoteNumbering.numbers.size > 0;
     const parsedBlocks = chapterEndNotes
-        ? appendChapterEndNotes(footnoteSplit.blocks, footnoteNumbering, footnoteDefs)
+        ? appendChapterEndNotes(footnoteSplit.blocks, footnoteNumbering, footnoteDefs, resolved.footnotes.markerPosition)
         : footnoteSplit.blocks;
     const headingStart = continuation?.headings;
     // `:::toc` expands into the entries of the book's outline — the one the
@@ -1591,7 +1600,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         let m = noteMeasures.get(key);
         if (m === undefined) {
             const number = footnoteNumbering.numbers.get(id) ?? '?';
-            m = measureContentBlock(noteContentBlock(footnoteDefs.get(id), id, number), 0, width, measureCtx, { styleOverride: noteStyle });
+            m = measureContentBlock(noteContentBlock(footnoteDefs.get(id), id, number, resolved.footnotes.markerPosition), 0, width, measureCtx, { styleOverride: noteStyle });
             noteMeasures.set(key, m);
         }
         return m;
@@ -2819,6 +2828,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
         /** The box already moved to a fresh page (or sits on an empty one):
          *  whatever does not fit there is force-placed and overflows. */
         let forceHere = false;
+        /** Times the box left a fresh page whose room the floats flushed onto
+         *  it had taken — bounded. */
+        let floatPageMoves = 0;
         for (;;) {
             let page = doc.pages[cursor.pageIndex];
             const continuation = part > 0;
@@ -2942,6 +2954,22 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     }
                 }
             }
+            // A fresh page whose room went to the floats flushed onto it (a
+            // figure page, a page-span figure standing upright across a vertical
+            // page) holds no text to cut: a box a page would hold moves on to the
+            // next page rather than overflow this one.
+            if (!action && forceHere && fit && floatPageMoves < 2
+                && fit.spacing + result.totalHeight > fit.roomPx + 0.5
+                && result.totalHeight <= contentArea.height + 0.01
+                && !pageHasContent(page) && (page.floats?.length ?? 0) > 0) {
+                floatPageMoves++;
+                pendingSpacing = 0;
+                const startPageIndex = cursor.pageIndex;
+                do {
+                    advanceToNextColumn(doc, cursor, geomResolved, contentArea, pageWidthPx, pageHeightPx, onNewPage);
+                } while (cursor.pageIndex === startPageIndex);
+                continue;
+            }
             if (!action && forceHere && fit) {
                 action = { kind: 'whole', fit, need: fit.need, result };
                 // A box that fills its band to the last grid line is not an overflow.
@@ -5309,21 +5337,68 @@ function* buildDocumentRounds(content, config, cache, options) {
         const parsed = parseMarkdownMemo(extractFrontmatter(content.markdown).content);
         if (hasTocDirective(parsed) || hasIndexDirective(parsed)) {
             let outline = computeOutline(parsed, resolveAllConfig(config), content.continuation?.headings);
-            let doc = withIndexMarks(yield* buildDocumentBalanced({ ...content, outline }, config, cache, options, 0), content);
+            let doc = withIndexMarks(yield* buildDocumentNumbered({ ...content, outline }, config, cache, options, 0), content);
             for (let round = 0; round < MAX_TOC_ROUNDS; round++) {
                 const after = outlineFromDoc(doc, outline);
                 if (sameOutline(after, outline))
                     break;
                 outline = after;
-                doc = withIndexMarks(yield* buildDocumentBalanced({ ...content, outline }, config, cache, options, round + 1), content);
+                doc = withIndexMarks(yield* buildDocumentNumbered({ ...content, outline }, config, cache, options, round + 1), content);
             }
             return doc;
         }
     }
-    return withIndexMarks(yield* buildDocumentBalanced(content, config, cache, options), content);
+    return withIndexMarks(yield* buildDocumentNumbered(content, config, cache, options), content);
+}
+/** The number each note's marker prints in `doc` (its first marker). */
+function printedFootnoteNumbers(doc) {
+    const out = new Map();
+    for (const block of doc.blocks) {
+        if (block.footnoteNote !== undefined)
+            continue;
+        for (const line of block.lines) {
+            for (const seg of line.segments ?? []) {
+                if (seg.footnoteId !== undefined && !out.has(seg.footnoteId))
+                    out.set(seg.footnoteId, seg.text);
+            }
+        }
+    }
+    return out;
+}
+/** Builds a document numbering its notes by page (or column) gets at most,
+ *  beyond the first, for the numbers to settle. */
+const MAX_FOOTNOTE_ROUNDS = 3;
+/**
+ * {@link buildDocumentBalanced}, with `footnotes.numbering: 'page'` /
+ * `'column'`: a note's number depends on the page the layout sets it on,
+ * so the document is numbered by chapter, laid out, numbered again where
+ * its notes landed, and laid out with those numbers until they no longer
+ * change (as the contents' page labels are). A circled marker is the same
+ * width whatever its number, so the second build reflows nothing and the
+ * numbers hold; a decimal one may move a line (9 → 10), hence the bound.
+ */
+function* buildDocumentNumbered(content, config, cache, options, tocRound = 0) {
+    let doc = yield* buildDocumentBalanced(content, config, cache, options, tocRound);
+    const f = doc.config.footnotes;
+    if (f.placement !== 'column' || (f.numbering !== 'page' && f.numbering !== 'column'))
+        return doc;
+    for (let round = 0; round < MAX_FOOTNOTE_ROUNDS; round++) {
+        const used = printedFootnoteNumbers(doc);
+        if (used.size === 0)
+            break;
+        const placed = numberFootnotesByPlacement(doc.pages, f.numbering, f.numberFormat).numbers;
+        // A note the layout set nowhere keeps the number it had.
+        const next = new Map(used);
+        for (const [id, number] of placed)
+            next.set(id, number);
+        if (sameFootnoteNumbers(next, used))
+            break;
+        doc = yield* buildDocumentBalanced(content, config, cache, options, tocRound, next);
+    }
+    return doc;
 }
 const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
-function* buildDocumentBalanced(content, config, cache, options, tocRound = 0) {
+function* buildDocumentBalanced(content, config, cache, options, tocRound = 0, footnoteNumbers) {
     // Each pass reports its own progress, numbered in build order.
     let passIndex = 0;
     const onProgress = options?.onProgress;
@@ -5337,7 +5412,7 @@ function* buildDocumentBalanced(content, config, cache, options, tocRound = 0) {
     const runPass = (hints) => {
         passIndex++;
         const started = onPass ? now() : 0;
-        const result = buildDocumentPass(content, config, cache, passOptions, { ...hints, captionUnder });
+        const result = buildDocumentPass(content, config, cache, passOptions, { ...hints, captionUnder, ...(footnoteNumbers ? { footnoteNumbers } : {}) });
         for (const id of result.captionUnderProposals)
             captionUnder.add(id);
         onPass?.({ pass: passIndex, tocRound, ms: now() - started, pages: result.doc.pages.length });