postext 1.40.0 → 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';
@@ -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);
@@ -5997,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) => {
@@ -6010,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,
@@ -6143,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);
@@ -6164,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--) {
@@ -6178,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));
@@ -6201,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,
@@ -8699,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)
@@ -8867,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
@@ -8880,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) {
@@ -8887,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;
@@ -8910,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);