postext 1.39.1 → 1.41.0

package/dist/pipeline/build.js

@@ -44,7 +44,8 @@ import { layoutComposedSpread } from '../composed/spread';
 import { assignJumpReceivers, assignReceivers, continuationTarget, MAX_CONTINUATION_PAGES } from '../composed/continuation';
 import { frameElementId } from '../composed/ids';
 import { nextFrameOf } from '../composed/geometry';
-import { composedPageAt, frameStyleOf, layoutComposedPage, planComposedPages } from './composedLayout';
+import { carriedPass, composedPageAt, frameStyleOf, layoutComposedPage, planComposedPages } from './composedLayout';
+import { importJumps } from '../composed/carry';
 import { configKeyOf, layoutComposedPageMemo } from '../composed/pageMemo';
 import { anchorOutline, computeOutline, hasIndexDirective, hasTocDirective, headingNumberingOptions, headingTemplatesOf, outlineFromDoc, sameOutline } from './outline';
 import { expandTocDirectives } from './toc';
@@ -55,8 +56,8 @@ import { resetLinePositions, createPageWithColumns, currentColumn, advanceToNext
 import { chooseParagraphSplit } from './orphanWidow';
 import { layoutComicPage, comicPageLayoutWarnings } from '../comics/layoutPage';
 import { comicStripExtent, comicStripOffset, comicStripPlacement, comicStripWidth, layoutComicStrip } from '../comics/strip';
-import { isComicSpread, layoutComicSpread } from '../comics/spread';
-import { comicTextPanelsSupported, layoutComicTextFrames, planComicTextPanels, wrapComicTextPanels } from '../comics/textPanels';
+import { comicSpreadGutter, isComicSpread, layoutComicSpread } from '../comics/spread';
+import { comicTextPanelsSupported, layoutComicTextFrames, layoutStripTextFrames, planComicTextPanels, wrapComicTextPanels } from '../comics/textPanels';
 import { applyStyleAttrs, computePageMetrics, flowPageMirrored, pageMirrored, sheetRectToFlow, isMarkerBlock, nextNonMarkerBlock, spaceLinesAfter, prevNonMarkerBlock, rollbackTrailingBlocks, } from './buildHelpers';
 import { measureContentBlock } from './measureContentBlock';
 import { containerStyle, paragraphStyleIdOf, planParagraphContainers } from './paragraphContainers';
@@ -485,7 +486,9 @@ function placeDocumentPass(content, config, cache, options, hints) {
     const anchorRefs = hasAnchorRefs(parsedBlocks, resourceIds);
     const outline = content.outline
         ?? (hasTocDirective(parsedBlocks) || hasIndexDirective(parsedBlocks) || anchorRefs ? computeOutline(parsedBlocks, resolved, headingStart, continuation?.statementCounters) : undefined);
-    const anchorRefContext = anchorRefs
+    // A story carried in from another chapter (#943) may refer to anchors too.
+    const carriedRefs = continuation?.jumps?.some((j) => j.outline) === true;
+    const anchorRefContext = anchorRefs || carriedRefs
         ? { targets: anchorTargetsOf(outline), strings: resolved.crossRefs }
         : undefined;
     const indexExpanded = expandIndexDirectives(expandTocDirectives(parsedBlocks, outline, resolved), outline, resolved);
@@ -518,6 +521,15 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // callout machinery places and splits.
     const codeBoxes = wrapCodeBlocks(spanEmbeds.blocks, resolved);
     const contentBlocks = codeBoxes.blocks;
+    // Stories of earlier chapters that jump into a page of this one (#943):
+    // appended past the chapter's blocks by the composed pages' layout, with
+    // the notes they cite numbered as their chapter numbered them.
+    const carried = continuation?.jumps && continuation.jumps.length > 0 ? importJumps(continuation.jumps, contentBlocks.length, bodyOffset) : undefined;
+    for (const note of carried?.footnotes ?? []) {
+        footnoteNumbering.numbers.set(note.id, note.number);
+        if (note.def)
+            footnoteDefs.set(note.id, note.def);
+    }
     if (indexExpanded.warnings.length > 0)
         indexWarnings.set(doc, indexExpanded.warnings);
     const isNumbered = (b) => headingIsNumbered(b, resolved);
@@ -5712,7 +5724,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
      * needed; the verso and the recto after it get one half each
      * (`layoutComicSpread`). The cursor is left on the recto.
      */
-    const placeComicSpread = (source) => {
+    const placeComicSpread = (source, textPlan) => {
         breakToEvenPage();
         const verso = doc.pages[cursor.pageIndex];
         verso.columns = [createVDTColumn(0, verso.contentArea)];
@@ -5738,6 +5750,17 @@ function placeDocumentPass(content, config, cache, options, hints) {
         });
         verso.comic = versoIsLeft ? left : right;
         recto.comic = versoIsLeft ? right : left;
+        // The text panels (#959): each on the page that holds most of its
+        // panel, off the gutter.
+        if (textPlan) {
+            const sides = [[verso, verso.comic, recto.comic], [recto, recto.comic, verso.comic]];
+            for (const [page, own, other] of sides) {
+                const width = (c, index) => c.panels.find((q) => q.index === index)?.bbox.width ?? 0;
+                const mine = new Set(own.panels.filter((q) => width(own, q.index) > width(other, q.index) || (width(own, q.index) === width(other, q.index) && page === (versoIsLeft ? verso : recto))).map((q) => q.index));
+                const gutter = comicSpreadGutter(own, dpi, page.height);
+                placeComicText(page, own, textPlan, { only: mine, ...(gutter ? { avoid: [gutter] } : {}) });
+            }
+        }
     };
     /**
      * `:::strip` (#566): a comic in the flow, kept together. Set `here`, it
@@ -5986,6 +6009,93 @@ function placeDocumentPass(content, config, cache, options, hints) {
     }
     /** Stories waiting for the later page fence they jump to, by its id. */
     const jumps = new Map();
+    /** The closing marker of the fence each composed page was set from. */
+    const fenceEnd = new Map();
+    /** The carried stories are laid through a pass that answers for them;
+     *  they wait for their fence with the others. */
+    const composedPass = carried ? carriedPass(framePass, carried) : framePass;
+    /** Stories of this chapter that jump into a page of a later one (#943). */
+    const pendingJumps = [];
+    /** The rest of the story `c` cut, as the chapter it goes to needs it
+     *  (#943): its box and children as this chapter has them ready to lay,
+     *  the cut, and the numbers the lookups by position would give. */
+    const exportJump = (c, page) => {
+        const startIdx = c.story.startIdx;
+        const again = carried?.stories.get(startIdx);
+        const all = composedPass.contentBlocks;
+        const blocks = all.slice(startIdx, c.story.plan.endIdx + 1);
+        const numbers = again ? [...(again.jump.numbers ?? [])] : [];
+        if (!again) {
+            for (let i = startIdx; i <= c.story.plan.endIdx; i++) {
+                if (headingPrefixes[i] === undefined && headingNumbers[i] === undefined)
+                    continue;
+                numbers.push({
+                    at: i - startIdx,
+                    ...(headingPrefixes[i] !== undefined ? { prefix: headingPrefixes[i] } : {}),
+                    ...(headingNumbers[i] !== undefined ? { value: headingNumbers[i] } : {}),
+                    ...(chapterNumberByBlock[i] ? { chapterNumber: chapterNumberByBlock[i] } : {}),
+                });
+            }
+        }
+        const notes = [];
+        const seen = new Set();
+        for (const b of blocks) {
+            for (const span of b.spans) {
+                const id = span.footnote?.id;
+                if (id === undefined || seen.has(id))
+                    continue;
+                seen.add(id);
+                const number = footnoteNumbering.numbers.get(id);
+                if (number === undefined)
+                    continue;
+                const def = footnoteDefs.get(id);
+                notes.push({ id, number, ...(def ? { def } : {}) });
+            }
+        }
+        const rule = c.rule;
+        const frame = continueInPage(rule)?.frame;
+        return {
+            ...(again ? { chapter: again.chapter } : {}),
+            target: page,
+            ...(frame !== undefined ? { targetFrame: frame } : {}),
+            rule,
+            frame: c.frame,
+            fromFrameId: c.fromFrameId,
+            head: c.head,
+            template: c.template,
+            collapsed: c.collapsed,
+            slot: c.slot,
+            pieces: c.pieces,
+            headBlockId: c.headBlockId,
+            ...(c.trailing ? { trailing: c.trailing } : {}),
+            ...(c.fromMark !== undefined ? { fromMark: c.fromMark } : {}),
+            cut: c.cut,
+            blocks: blocks,
+            bodyOffset,
+            ...(numbers.length > 0 ? { numbers } : {}),
+            orderedLevelIndentsPx: again?.jump.orderedLevelIndentsPx ?? orderedLevelIndentsPx,
+            ...(notes.length > 0 ? { footnotes: notes } : {}),
+            ...(hasAnchorRefs(blocks, new Set((content.resources ?? []).map((r) => r.id))) ? { outline: true } : {}),
+        };
+    };
+    for (const [id, list] of carried?.byTarget ?? []) {
+        if (fenceById.has(id)) {
+            jumps.set(id, [...(jumps.get(id) ?? []), ...list]);
+            continue;
+        }
+        // The host named this chapter for a page it does not have.
+        for (const c of list) {
+            composedNotes.push({
+                kind: 'continueTargetMissing',
+                template: c.template,
+                frame: c.frame,
+                fenceIndex: -1,
+                target: id,
+                fromChapter: c.foreign?.chapter ?? -1,
+                configPath: '',
+            });
+        }
+    }
     /** Set the composed page `planned` on a fresh page (#855), or a spread
      *  template on the two facing pages from the next verso (#861). */
     const placeComposedPage = (planned, fence) => {
@@ -5999,7 +6109,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
          *  other templates of the same kind (single pages for this side, or
          *  spreads). */
         const common = (page, current) => ({
-            pass: framePass,
+            pass: composedPass,
             fence,
             startIdx: planned.startIdx,
             endIdx: planned.endIdx,
@@ -6132,6 +6242,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         const commit = (list) => {
             for (const { page, composed, blocks } of list) {
                 page.composed = composed;
+                fenceEnd.set(composed, planned.endIdx);
                 const floats = (page.floats ??= []);
                 for (const b of blocks) {
                     floats.push(b);
@@ -6153,12 +6264,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
         indexFrames(placed);
         /** The sending frame of `c` points to the frame `to` that took it, and
          *  its page's log says where it went. */
-        const link = (c, to) => {
-            const src = frameAt.get(c.fromFrameId);
-            const dst = frameAt.get(to);
-            if (!src || !dst)
-                return;
-            src.frame.continuesTo = to;
+        const logContinued = (src, c, event) => {
             const log = src.page.composed.log;
             let at = log.length;
             for (let i = log.length - 1; i >= 0; i--) {
@@ -6167,7 +6273,19 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     break;
                 }
             }
-            log.splice(at, 0, { frame: c.frame, kind: 'continued', toPage: dst.page.index, toFrame: to });
+            log.splice(at, 0, { frame: c.frame, kind: 'continued', ...event });
+        };
+        const link = (c, to) => {
+            // The sending frame is on a page of another chapter: the host links
+            // the two (`resolveJumpMarks`).
+            if (c.foreign)
+                return;
+            const src = frameAt.get(c.fromFrameId);
+            const dst = frameAt.get(to);
+            if (!src || !dst)
+                return;
+            src.frame.continuesTo = to;
+            logContinued(src, c, { toPage: dst.page.index, toFrame: to });
         };
         for (const [name, c] of jumpReceivers)
             link(c, frameElementId(fence.fenceIndex, name));
@@ -6190,6 +6308,16 @@ function placeDocumentPass(content, config, cache, options, hints) {
                     continue;
                 }
                 const from = frameAt.get(c.fromFrameId);
+                // A page of a later chapter (#943): the host hands the rest over.
+                const later = !to && content.laterPageIds && Object.prototype.hasOwnProperty.call(content.laterPageIds, target.page) ? content.laterPageIds[target.page] : undefined;
+                if (later !== undefined) {
+                    pendingJumps.push(exportJump(c, target.page));
+                    if (from) {
+                        from.frame.continuesToChapter = later;
+                        logContinued(from, c, { toChapter: later });
+                    }
+                    continue;
+                }
                 composedNotes.push({
                     kind: 'continueTargetMissing',
                     template: c.template,
@@ -6308,13 +6436,12 @@ function placeDocumentPass(content, config, cache, options, hints) {
      * frame (`layoutComicTextFrames`), its blocks floats of the page; the
      * stories laid are done for the main loop.
      */
-    const placeComicText = (page, comic, plan) => {
+    const comicTextBase = (page, plan) => {
         const frameless = calloutStyles.find((st) => st.id === FRAME_STYLE_ID);
-        const out = layoutComicTextFrames({
+        return {
             pass: framePass,
             resolved,
             page,
-            comic,
             plan,
             styleOf: (frame) => frameStyleOf((frame.style ? resolved.calloutStyles.find((st) => st.id === frame.style) : undefined) ?? frameless, frame),
             dpi,
@@ -6323,19 +6450,64 @@ function placeDocumentPass(content, config, cache, options, hints) {
             mirrored: mirroredOf(page),
             pushGapPx: wrapGapPx(resolved.layout.wrap?.gap, dpi, bodyStyle.fontSizePx, floatGapPx),
             locale: resolvedLocale(resolved),
-        });
+        };
+    };
+    /** The blocks a comic's text frames set, floats of the page. */
+    const addComicTextBlocks = (page, blocks) => {
         const floats = (page.floats ??= []);
-        for (const b of out.blocks) {
+        for (const b of blocks) {
             floats.push(b);
             doc.blocks.push(b);
         }
+    };
+    /** The stories of a plan are done for the main loop. */
+    const markComicStoriesLaid = (plan, laid) => {
         for (const [key, story] of plan.stories) {
-            if (!out.laid.has(key))
+            if (laid && !laid.has(key))
                 continue;
             for (let i = story.startIdx; i <= story.plan.endIdx; i++)
                 composedLaid.add(i);
         }
     };
+    // The text panels of a strip are laid where the strip ends up
+    // (`placeStripTexts`): the blocks that follow it are done from the start.
+    for (const [idx, plan] of comicTextPlans)
+        if (contentBlocks[idx]?.directiveName === 'strip')
+            markComicStoriesLaid(plan);
+    const placeComicText = (page, comic, plan, extra) => {
+        const out = layoutComicTextFrames({ ...extra, ...comicTextBase(page, plan), comic });
+        addComicTextBlocks(page, out.blocks);
+        markComicStoriesLaid(plan, out.laid);
+        return out;
+    };
+    /**
+     * The text panels of the strips on the pages (#959), laid where the strips
+     * stand once the pass has placed everything (a strip moves with its
+     * column, its band and the pages' final adjustments): each strip's comic
+     * moved onto the sheet, its stories set in the page's flow frame, the
+     * result written back on the strip.
+     */
+    const placeStripTexts = () => {
+        if (comicTextPlans.size === 0)
+            return;
+        for (const page of doc.pages) {
+            const strips = new Set();
+            for (const col of page.columns)
+                for (const b of col.blocks)
+                    if (b.comic && !b.hidden)
+                        strips.add(b);
+            for (const b of page.floats ?? [])
+                if (b.comic && !b.hidden)
+                    strips.add(b);
+            for (const block of strips) {
+                const plan = block.contentIndex !== undefined && block.contentIndex >= 0 ? comicTextPlans.get(block.contentIndex) : undefined;
+                if (!plan)
+                    continue;
+                const out = layoutStripTextFrames({ ...comicTextBase(page, plan), block });
+                addComicTextBlocks(page, out.blocks);
+            }
+        }
+    };
     /** The first block of the document that sets something: a heading there
      *  opens the document's first page (`openerPages`, #749). */
     const firstFlowBlockIdx = contentBlocks.findIndex((b) => !isMarkerBlock(b) && b.type !== 'directive');
@@ -6607,7 +6779,7 @@ function placeDocumentPass(content, config, cache, options, hints) {
                 leaveCurrentPage();
                 cursor.columnIndex = 0;
                 if (isComicSpread(rawBlock.comic))
-                    placeComicSpread(rawBlock.comic);
+                    placeComicSpread(rawBlock.comic, comicTextPlans.get(blockIdx));
                 else {
                     const page = doc.pages[cursor.pageIndex];
                     page.columns = [createVDTColumn(0, page.contentArea)];
@@ -8518,6 +8690,8 @@ function placeDocumentPass(content, config, cache, options, hints) {
         if (page)
             centrePageText(page, reservedOf);
     }
+    // The text panels of the strips, where the strips stand now (#959).
+    placeStripTexts();
     // A band that is still cut at the end of the pass (a trailing cap: the
     // closing band of a chapter or of the document) must hold what it took,
     // under the same rules as an uncut one. Two ways a cut too low breaks
@@ -8642,6 +8816,10 @@ function placeDocumentPass(content, config, cache, options, hints) {
     // Composed pages (#855): frames whose content does not fit.
     if (composedNotes.length > 0)
         composedWarningsByDoc.set(doc, composedNotes);
+    if (pendingJumps.length > 0)
+        doc.pendingJumps = pendingJumps;
+    if (carried)
+        stampCarriedSource(doc, carried, fenceEnd);
     // The composition rules (#749): short lists cut, floats on opener pages.
     const ruleNotes = [...shortListWarnings(), ...openerFloatNotes, ...tocGroupWarnings()];
     if (ruleNotes.length > 0)
@@ -8810,6 +8988,39 @@ function afterTextWarnings(doc) {
     }
     return out;
 }
+/**
+ * Mark the blocks laid from stories that came in from other chapters
+ * (#943): `VDTBlock.sourceChapter` says whose file their source offsets
+ * are offsets in.
+ */
+function stampCarriedSource(doc, carried, fenceEnd) {
+    const stories = [...carried.stories.values()];
+    const noteChapter = new Map(carried.footnotes.map((n) => [n.id, n.chapter]));
+    for (const block of doc.blocks) {
+        const note = block.footnoteNote !== undefined ? noteChapter.get(block.footnoteNote) : undefined;
+        if (note !== undefined)
+            block.sourceChapter = note;
+        const at = block.contentIndex;
+        if (at === undefined)
+            continue;
+        const story = stories.find((st) => at >= st.startIdx && at <= st.endIdx);
+        if (story)
+            block.sourceChapter = story.chapter;
+    }
+    // The frames that set a carried story's text: the box (a block of the
+    // frame) says whose it is.
+    for (const page of doc.pages) {
+        for (const frame of page.composed?.frames ?? []) {
+            const box = frame.blockIds.length > 0 ? page.floats?.find((b) => b.id === frame.blockIds[0]) : undefined;
+            if (box?.sourceChapter === undefined)
+                continue;
+            frame.sourceChapter = box.sourceChapter;
+            const end = fenceEnd.get(page.composed);
+            if (end !== undefined)
+                frame.readIndex = end + 0.5;
+        }
+    }
+}
 /**
  * Write the page numbers into the continuation marks of composed pages'
  * frames (#917, `VDTDesignTextBlock.pageMark`): `{page}` becomes the label
@@ -8823,6 +9034,22 @@ function fillPageMarks(pages) {
         for (const f of p.composed?.frames ?? [])
             if (!f.facingBlocks)
                 frames.set(f.id, p);
+    forEachPageMark(pages, (f, d) => {
+        // A page of another chapter is `resolveJumpMarks`'s (its frame ids are
+        // another chapter's).
+        if ((d.pageMark.page === 'to' ? f.continuesToChapter : f.continuedFromChapter) !== undefined)
+            return undefined;
+        const other = d.pageMark.page === 'to' ? f.continuesTo : f.continuedFrom;
+        const at = other !== undefined ? frames.get(other) : undefined;
+        return at ? pageLabelOf(at) : undefined;
+    });
+}
+/** The label a page prints. */
+const pageLabelOf = (page) => page.pageLabel ?? String(page.pageNumberValue ?? page.index + 1);
+/** Each continuation mark with a page number of `pages`' composed frames,
+ *  with `label` answering for the page it names: the mark's text is laid
+ *  out again with the number when it answers. */
+function forEachPageMark(pages, label) {
     for (const p of pages) {
         for (const f of p.composed?.frames ?? []) {
             for (const id of f.blockIds) {
@@ -8830,12 +9057,10 @@ function fillPageMarks(pages) {
                 for (const d of box?.designOverlay?.blocks ?? []) {
                     if (d.kind !== 'text' || !d.pageMark)
                         continue;
-                    const other = d.pageMark.page === 'to' ? f.continuesTo : f.continuedFrom;
-                    const at = other !== undefined ? frames.get(other) : undefined;
-                    if (!at)
+                    const shown = label(f, d);
+                    if (shown === undefined)
                         continue;
-                    const label = at.pageLabel ?? String(at.pageNumberValue ?? at.index + 1);
-                    const text = d.pageMark.text.split('{page}').join(label);
+                    const text = d.pageMark.text.split('{page}').join(shown);
                     const lh = d.lines.length > 0 ? d.bbox.height / d.lines.length : d.bbox.height;
                     const first = d.lines[0];
                     const slack0 = first ? d.bbox.width - first.width : 0;
@@ -8853,6 +9078,60 @@ function fillPageMarks(pages) {
         }
     }
 }
+/**
+ * Link the stories that jump from one chapter to a page of another (#943)
+ * and write the page numbers into their continuation marks. `docs` is the
+ * book laid out, one document per chapter, in the order of the book (a
+ * story's `chapter` is its position in it): the sending frame gets the
+ * frame that took the rest (`continuesTo`, its `continued` event the page
+ * and frame there), and every mark naming a page of another chapter
+ * prints that page's label as its chapter numbered it. Marks within a
+ * chapter were filled by its own build. Safe to run again on the same
+ * documents.
+ */
+export function resolveJumpMarks(docs) {
+    const byId = docs.map((doc) => {
+        const out = new Map();
+        for (const p of doc.pages)
+            for (const f of p.composed?.frames ?? [])
+                if (!f.facingBlocks)
+                    out.set(f.id, p);
+        return out;
+    });
+    const frameOf = (chapter, id) => {
+        const page = byId[chapter]?.get(id);
+        const frame = page?.composed?.frames.find((f) => f.id === id);
+        return page && frame ? { page, frame } : undefined;
+    };
+    // The receiving frames name where their story came from; give the
+    // sending frame the way on.
+    docs.forEach((doc) => {
+        for (const p of doc.pages) {
+            for (const f of p.composed?.frames ?? []) {
+                if (f.continuedFromChapter === undefined || f.continuedFrom === undefined)
+                    continue;
+                const from = frameOf(f.continuedFromChapter, f.continuedFrom);
+                if (!from)
+                    continue;
+                from.frame.continuesTo = f.id;
+                const event = from.page.composed.log.find((e) => e.kind === 'continued' && e.frame === from.frame.name && e.toChapter !== undefined);
+                if (event) {
+                    event.toPage = p.index;
+                    event.toFrame = f.id;
+                }
+            }
+        }
+    });
+    docs.forEach((doc) => {
+        forEachPageMark(doc.pages, (f, d) => {
+            const [chapter, id] = d.pageMark.page === 'to' ? [f.continuesToChapter, f.continuesTo] : [f.continuedFromChapter, f.continuedFrom];
+            if (chapter === undefined || id === undefined)
+                return undefined;
+            const at = byId[chapter]?.get(id);
+            return at ? pageLabelOf(at) : undefined;
+        });
+    });
+}
 /** `doc` with the page of each of its index marks (`doc.indexMarks`). */
 function withIndexMarks(doc, content) {
     const { content: body, contentOffset } = extractFrontmatter(content.markdown);