postext 1.39.1 → 1.41.0

package/dist/pipeline/composedLayout.js

@@ -15,6 +15,9 @@ import { frameElementId } from '../composed/ids';
 import { frameLinePx, frameRuleBlocks } from '../composed/rules';
 import { offsetCalloutToAbsolute } from './calloutLayout';
 import { isMarkerBlock } from './buildHelpers';
+import { createMeasureMemo } from './measureMemo';
+import { computeOrderedListRunMetrics } from './lists';
+import { planParagraphContainers } from './paragraphContainers';
 import { CUT_START, fragmentRange, frameCutRules, makeCalloutLayouter, splitCalloutFragment } from './frameLayout';
 const MM_PER_IN = 25.4;
 const NO_FIT = { patches: new Map(), text: new Map(), pictures: new Map(), yieldAll: new Set(), goOn: new Set() };
@@ -66,7 +69,10 @@ export function layoutComposedPage(given) {
     // A page added by continuation (#859) lays its template with the
     // continuation's rules (and, for the template laid again, its other
     // frames collapsed).
-    const input = given.continuing ? { ...given, template: continuationTemplate(given.template, given.continuing) } : given;
+    // The ladder lays the page again at each step: the measurements of one
+    // step answer the next (#953).
+    const memoed = { ...given, pass: { ...given.pass, measureMemo: createMeasureMemo() } };
+    const input = given.continuing ? { ...memoed, template: continuationTemplate(given.template, given.continuing) } : memoed;
     const { template, fence, dpi } = input;
     const fi = fence.fenceIndex;
     const mmPx = dpi / MM_PER_IN;
@@ -427,14 +433,133 @@ export function layoutComposedPage(given) {
     }
     return { composed, blocks, warnings, laid, ...(fitted.size > 0 ? { fitted } : {}), ...(continuations.length > 0 ? { continuations } : {}) };
 }
+/** The pass of a trial layout (#953): `base` with `extra` blocks appended to
+ *  its content, each a copy of the block at `originOf[k]`, and every lookup
+ *  the box typesetter keys by content index answered for the appended
+ *  blocks as for the blocks they copy. The paragraph groups
+ *  (`paragraphContainers.byBlock`), the heading and list numbers, the drop
+ *  cap and indent rules (which read the neighbours of a block in
+ *  `contentBlocks`), the comic strips and heading designs follow the
+ *  copies, so a trial sets a merged story as the build sets the story
+ *  itself. The trial also keeps its own notes (`dropCapNotes`,
+ *  `joiningLetterSpacing`), which the build reports for the page it lays. */
+function trialPass(base, extra, originOf, measureOrigin) {
+    const n = base.contentBlocks.length;
+    const at = (idx) => (idx < n ? idx : originOf[idx - n] ?? idx);
+    const extend = (arr) => (arr && extra.length > 0 ? [...arr, ...originOf.map((o) => arr[o])] : arr);
+    const contentBlocks = extra.length > 0 ? [...base.contentBlocks, ...extra] : base.contentBlocks;
+    const contexts = new Map();
+    const trialCtx = (ctx) => {
+        const known = contexts.get(ctx);
+        if (known)
+            return known;
+        const perBlock = new Map(ctx.orderedMetrics.perBlock);
+        originOf.forEach((o, k) => {
+            const m = ctx.orderedMetrics.perBlock.get(o);
+            if (m)
+                perBlock.set(n + k, m);
+        });
+        const out = {
+            ...ctx,
+            contentBlocks,
+            headingPrefixes: extend(ctx.headingPrefixes),
+            ...(ctx.headingNumbers ? { headingNumbers: extend(ctx.headingNumbers) } : {}),
+            orderedMetrics: { ...ctx.orderedMetrics, perBlock },
+            dropCapNotes: new Map(),
+            joiningLetterSpacing: new Set(),
+        };
+        contexts.set(ctx, out);
+        return out;
+    };
+    const byBlock = base.paragraphContainers.byBlock;
+    return {
+        ...base,
+        contentBlocks,
+        paragraphContainers: extra.length > 0 ? { byId: base.paragraphContainers.byId, byBlock: [...byBlock, ...originOf.map((o) => byBlock[o])] } : base.paragraphContainers,
+        // A merged story's box is set in the context of the story whose box
+        // it replaces.
+        measureCtxFor: (startIdx, style) => trialCtx(base.measureCtxFor(measureOrigin.get(startIdx) ?? startIdx, style)),
+        stripBlock: (raw, idx, width) => base.stripBlock(raw, at(idx), width),
+        ...(base.headingDesign ? { headingDesign: (raw, blockIdx, heading, width) => base.headingDesign(raw, at(blockIdx), heading, width) } : {}),
+    };
+}
+/**
+ * The pass the stories carried in from other chapters (#943) are laid with:
+ * `base` with their blocks appended to its content, and every lookup the
+ * box typesetter keys by content index answered for them from what the
+ * sender gave (heading numbers) or worked out again from the carried
+ * blocks alone (paragraph groups, ordered-list markers). A carried story's
+ * box is set in the context of the text, with the list indents its sender
+ * set its lists with; the typography of a styled section or a part of this
+ * chapter does not reach it.
+ */
+export function carriedPass(base, carried) {
+    if (carried.blocks.length === 0)
+        return base;
+    const n = base.contentBlocks.length;
+    const contentBlocks = [...base.contentBlocks, ...carried.blocks];
+    const local = planParagraphContainers(carried.blocks, base.resolved);
+    const byBlock = [...base.paragraphContainers.byBlock];
+    byBlock.length = n;
+    byBlock.push(...local.byBlock);
+    const paragraphContainers = { byId: new Map([...base.paragraphContainers.byId, ...local.byId]), byBlock };
+    const numberAt = new Map();
+    for (const story of carried.stories.values())
+        for (const [at, num] of story.numbers)
+            numberAt.set(at, num);
+    const extend = (arr, pick) => {
+        if (!arr)
+            return arr;
+        const out = [...arr];
+        out.length = n;
+        out.length = contentBlocks.length;
+        for (const [at, num] of numberAt)
+            out[at] = pick(num);
+        return out;
+    };
+    const contexts = new Map();
+    const carriedCtx = (ctx, startIdx) => {
+        const story = carried.stories.get(startIdx);
+        const of = contexts.get(ctx) ?? new Map();
+        contexts.set(ctx, of);
+        const known = of.get(startIdx);
+        if (known)
+            return known;
+        const metrics = computeOrderedListRunMetrics(carried.blocks, base.resolved, ctx.bodyStyle.fontSizePx);
+        const perBlock = new Map(ctx.orderedMetrics.perBlock);
+        for (const [i, m] of metrics.perBlock)
+            perBlock.set(n + i, m);
+        const out = {
+            ...ctx,
+            contentBlocks,
+            headingPrefixes: extend(ctx.headingPrefixes, (num) => num.prefix),
+            ...(ctx.headingNumbers ? { headingNumbers: extend(ctx.headingNumbers, (num) => num.value) } : {}),
+            orderedMetrics: { perBlock, maxWidthByDepth: ctx.orderedMetrics.maxWidthByDepth },
+            ...(story.jump.orderedLevelIndentsPx ? { orderedLevelIndentsPx: story.jump.orderedLevelIndentsPx } : {}),
+            dropCapNotes: new Map(),
+            joiningLetterSpacing: new Set(),
+        };
+        of.set(startIdx, out);
+        return out;
+    };
+    return {
+        ...base,
+        contentBlocks,
+        paragraphContainers,
+        measureCtxFor: (startIdx, style) => {
+            const ctx = base.measureCtxFor(startIdx, style);
+            return carried.stories.has(startIdx) ? carriedCtx(ctx, startIdx) : ctx;
+        },
+    };
+}
 /** The page's stories as `wrapComposedPages` would group them for template
  *  `alt` (#937): a story whose head names a frame of `alt` stays the story
  *  of that frame's chain, one a `takes` frame took goes to `alt`'s frame
  *  that takes the same level, and the rest go to `alt`'s flow frame, after
  *  its own content, in Markdown order. Merged stories are boxes appended
- *  past the pass's content blocks (a pass of their own), so the page can
- *  be laid with them. `undefined` when some content would leave the page
- *  (no frame of `alt` takes it). */
+ *  past the pass's content blocks (`trialPass`), so the page can be laid
+ *  with them. `undefined` when some content would leave the page (no frame
+ *  of `alt` takes it). */
 function regroupStories(input, alt) {
     const names = new Set(alt.frames.map((f) => f.name));
     const flow = alt.frames.find((f) => f.flow);
@@ -454,10 +579,13 @@ function regroupStories(input, alt) {
             return undefined;
         groups.set(to, [...(groups.get(to) ?? []), [head, story]]);
     }
+    // Every story stays its frame's own: the page as it is.
     if ([...groups].every(([to, list]) => list.length === 1 && list[0][0] === to))
-        return { pass: input.pass, stories: new Map(input.stories) };
+        return { pass: trialPass(input.pass, [], [], new Map()), stories: new Map(input.stories) };
     const base = input.pass.contentBlocks;
     const extra = [];
+    /** The block of the page each appended block copies. */
+    const originOf = [];
     /** Where each appended box's blocks come from: the first story's box. */
     const origin = new Map();
     let nextId = base.reduce((m, b) => Math.max(m, b.containerId ?? 0), 0) + 1;
@@ -473,19 +601,19 @@ function regroupStories(input, alt) {
         const startIdx = base.length + extra.length;
         const attrs = { ...own.plan.attrs, [FRAME_ATTR]: to };
         extra.push({ ...open, containerAttrs: attrs, containerId: id });
-        for (const [, s] of list)
+        originOf.push(own.startIdx);
+        for (const [, s] of list) {
             extra.push(...base.slice(s.startIdx + 1, s.plan.endIdx));
-        const close = base[list[list.length - 1][1].plan.endIdx];
-        extra.push({ ...close, containerId: id });
+            for (let i = s.startIdx + 1; i < s.plan.endIdx; i++)
+                originOf.push(i);
+        }
+        const last = list[list.length - 1][1];
+        extra.push({ ...base[last.plan.endIdx], containerId: id });
+        originOf.push(last.plan.endIdx);
         origin.set(startIdx, own.startIdx);
         stories.set(to, { startIdx, plan: { endIdx: base.length + extra.length - 1, attrs, containerId: id } });
     }
-    const pass = {
-        ...input.pass,
-        contentBlocks: [...base, ...extra],
-        measureCtxFor: (startIdx, style) => input.pass.measureCtxFor(origin.get(startIdx) ?? startIdx, style),
-    };
-    return { pass, stories };
+    return { pass: trialPass(input.pass, extra, originOf, origin), stories };
 }
 /** The page fits when set with template `alt` (#937): its stories regrouped
  *  for it (`regroupStories`), its own reflow ladder run; no frame
@@ -682,9 +810,30 @@ function composePage(input, template, fit, collapsed) {
      *  mode, else undefined. Its content is laid out in that mode, its lines
      *  along the box's height and following each other across its width. */
     const pageMode = pageIsVertical(input.page) ? 'vertical-rl' : 'horizontal-tb';
-    // Not on a right-to-left page, whose mirrored flow would set a vertical
-    // frame's lines from left to right: there it keeps the page's mode.
-    const ownMode = (frame) => frame.writingMode !== undefined && frame.writingMode !== pageMode && !pageIsMirrored(input.page) ? frame.writingMode : undefined;
+    const ownMode = (frame) => frame.writingMode !== undefined && frame.writingMode !== pageMode ? frame.writingMode : undefined;
+    /** A vertical frame of a right-to-left page (#960): the page's flow is
+     *  painted mirrored, which would set its lines from left to right, so the
+     *  frame is laid out as on a left-to-right page and painted unmirrored
+     *  (`VDTFrame.unmirrorX`). The mirror's origin, else undefined. */
+    const unmirroredAt = (frame) => {
+        const flow = input.page.flow;
+        return ownMode(frame) && flow?.writingMode === 'horizontal-tb' ? flow.mirror.originX : undefined;
+    };
+    /** Whether a frame's lines are set as on a mirrored page: those of the
+     *  page's own mode, not an unmirrored frame's. */
+    const mirroredIn = (frame) => input.mirrored && unmirroredAt(frame) === undefined;
+    /** The widest a picture's upright frame may be in a vertical frame of a
+     *  horizontal page (#960): the frame's extent across its lines, less the
+     *  box's padding. The page turns such a frame a quarter turn, so its
+     *  pictures are laid out counter-rotated to stand upright; none of that
+     *  in a frame of the page's own mode. */
+    const uprightIn = (frame, across) => {
+        if (ownMode(frame) !== 'vertical-rl')
+            return {};
+        const pad = styleOf(frame).padding;
+        const room = across - lengthPx(pad.top, dpi, input.emPx) - lengthPx(pad.bottom, dpi, input.emPx);
+        return { uprightMaxLength: Math.max(1, room) };
+    };
     /** `fn` measured in the frame's own writing mode. */
     const inMode = (frame, fn) => {
         const mode = ownMode(frame);
@@ -847,8 +996,8 @@ function composePage(input, template, fit, collapsed) {
             const known = memo.get(key);
             if (known !== undefined)
                 return known;
-            const opts = { ...(pic !== undefined ? { pictureScale: pic } : {}), ...(p.fromMark !== undefined ? { continuedMark: p.fromMark } : {}) };
-            const across = (measure) => inMode(p.frame, () => p.st.L.layoutRange(p.st.cut, p.st.L.end, measure / s, p.blockId, p.continuation, input.mirrored, Object.keys(opts).length > 0 ? opts : undefined).totalHeight * s);
+            const opts = { ...(pic !== undefined ? { pictureScale: pic } : {}), ...(p.fromMark !== undefined ? { continuedMark: p.fromMark } : {}), ...uprightIn(p.frame, width / s) };
+            const across = (measure) => inMode(p.frame, () => p.st.L.layoutRange(p.st.cut, p.st.L.end, measure / s, p.blockId, p.continuation, mirroredIn(p.frame), Object.keys(opts).length > 0 ? opts : undefined).totalHeight * s);
             const most = Math.max(input.areas.area.height, input.emPx);
             let h = most;
             if (across(most) <= width + 0.5) {
@@ -1066,9 +1215,9 @@ function composePage(input, template, fit, collapsed) {
                 // Text running round the frames that push it runs along the page's
                 // lines: a frame set across them keeps its whole box.
                 const exclusions = turned ? undefined : unscale(exclusionsFor(frame, rect, false), s);
-                const extra = { ...(exclusions ? { exclusions } : {}), ...(pic !== undefined ? { pictureScale: pic } : {}), ...(p.fromMark !== undefined ? { continuedMark: p.fromMark } : {}) };
+                const extra = { ...(exclusions ? { exclusions } : {}), ...(pic !== undefined ? { pictureScale: pic } : {}), ...(p.fromMark !== undefined ? { continuedMark: p.fromMark } : {}), ...uprightIn(frame, laidH) };
                 const opts = { boxHeight: laidH, verticalAlign: frame.verticalAlign, ...extra };
-                const whole = inMode(frame, () => st.L.layoutRange(from, st.L.end, laidW, blockId, continuation, input.mirrored, opts));
+                const whole = inMode(frame, () => st.L.layoutRange(from, st.L.end, laidW, blockId, continuation, mirroredIn(frame), opts));
                 const nextName = nextFrameOf(frame);
                 const nextFrame = nextName !== undefined ? byName.get(nextName) : undefined;
                 const chained = nextFrame !== undefined && !vdtByName.has(nextFrame.name);
@@ -1080,11 +1229,11 @@ function composePage(input, template, fit, collapsed) {
                     const minLines = Math.max(1, style.splitMinLines);
                     // A heading stays with what follows it, a list keeps two items
                     // on each side of the cut (#913).
-                    const frag = inMode(frame, () => splitCalloutFragment(pass, st.L, from, laidW, laidH, blockId, continuation, minLines, input.mirrored, extra.exclusions || extra.pictureScale !== undefined || extra.continuedMark !== undefined ? extra : undefined, cutRules));
+                    const frag = inMode(frame, () => splitCalloutFragment(pass, st.L, from, laidW, laidH, blockId, continuation, minLines, mirroredIn(frame), extra.exclusions || extra.pictureScale !== undefined || extra.continuedMark !== undefined || extra.uprightMaxLength !== undefined ? extra : undefined, cutRules));
                     const to = frag?.to ?? from;
                     // A frame none of whose content fits draws nothing: the whole box
                     // goes on (#912), not a tab and a mark over an empty piece.
-                    result = frag ? inMode(frame, () => st.L.layoutRange(from, to, laidW, blockId, continuation, input.mirrored, opts)) : undefined;
+                    result = frag ? inMode(frame, () => st.L.layoutRange(from, to, laidW, blockId, continuation, mirroredIn(frame), opts)) : undefined;
                     st.cut = to;
                 }
                 else {
@@ -1096,7 +1245,7 @@ function composePage(input, template, fit, collapsed) {
             }
             else if (st && frame.style) {
                 // A styled frame with nothing (left) to hold still draws its box.
-                result = inMode(frame, () => st.L.layoutRange(st.L.end, st.L.end, laidW, blockId, true, input.mirrored, { boxHeight: laidH }));
+                result = inMode(frame, () => st.L.layoutRange(st.L.end, st.L.end, laidW, blockId, true, mirroredIn(frame), { boxHeight: laidH }));
             }
             // A frame cut below its least height overflows by the cut, holding
             // content or not (#911).
@@ -1126,6 +1275,7 @@ function composePage(input, template, fit, collapsed) {
                 rect: { ...rect },
                 rotate: frame.rotate + (turned ? frameModeTurn({ writingMode: turned }) : 0),
                 ...(turned ? { writingMode: turned } : {}),
+                ...(unmirroredAt(frame) !== undefined ? { unmirrorX: unmirroredAt(frame) } : {}),
                 layer: frame.layer,
                 ...(frame.style ? { styleId: frame.style } : {}),
                 scale: s,
@@ -1149,7 +1299,11 @@ function composePage(input, template, fit, collapsed) {
             }
             else if (holds && cont?.receivers.has(frame.name)) {
                 // Content from the page before (#859).
-                vdt.continuedFrom = cont.receivers.get(frame.name).fromFrameId;
+                const came = cont.receivers.get(frame.name);
+                vdt.continuedFrom = came.fromFrameId;
+                // From a page of an earlier chapter (#943).
+                if (came.foreign)
+                    vdt.continuedFromChapter = came.foreign.from;
             }
             if (result) {
                 // The marks whose `{page}` the build fills in (#917).