@segnavia/html 0.27.0 → 0.28.0

package/dist/book/paginate-book.d.ts

@@ -0,0 +1,11 @@
+import { PaginateBookInput, PaginateBookResult } from "./paginate-types.js";
+import { paginateColumns } from "./paginate-columns.js";
+import { paginateKeeps } from "./paginate-keeps.js";
+import { paginateMarks } from "./paginate-marks.js";
+import { paginateNotes } from "./paginate-notes.js";
+import { paginateSequence } from "./paginate-sequence.js";
+//#region src/book/paginate-book.d.ts
+export declare function paginateBook(input: PaginateBookInput): PaginateBookResult;
+export declare const PAGINATE_FUNCTIONS: (typeof paginateColumns | typeof paginateNotes | typeof paginateKeeps | typeof paginateMarks | typeof paginateSequence)[];
+export declare function paginateScript(): string;
+//#endregion

package/dist/book/paginate-book.js

@@ -0,0 +1,195 @@
+import { paginateColumns } from "./paginate-columns.js";
+import { paginateKeeps } from "./paginate-keeps.js";
+import { paginateMarks } from "./paginate-marks.js";
+import { paginateNotes } from "./paginate-notes.js";
+import { paginateSequence } from "./paginate-sequence.js";
+//#region src/book/paginate-book.ts
+function paginateBook(input) {
+	const textHeight = input.geometry.textHeight;
+	const orphans = input.settings.orphans ?? 2;
+	const widows = input.settings.widows ?? 2;
+	function used(placed, fragments) {
+		return paginateColumns(placed).height + paginateNotes({
+			op: "space",
+			notes: input.notes,
+			geometry: input.geometry,
+			fragments
+		});
+	}
+	function withNotes(extra) {
+		return {
+			notes: input.notes,
+			geometry: input.geometry,
+			used,
+			...extra
+		};
+	}
+	function refusal(block) {
+		const position = `chapter ${block.position.chapter} block ${block.position.block}`;
+		return {
+			tag: block.tag,
+			position: block.position,
+			message: `The ${block.tag} at ${position} could not establish a fit in the text area; shorten it or increase the text-area height to clear this refusal.`
+		};
+	}
+	function blockForNote(id) {
+		for (const flow of input.flows) {
+			if (flow.kind === "fixed") continue;
+			for (const candidate of flow.blocks) if (candidate.footnoteRefs?.some((ref) => ref.note === id)) return candidate;
+		}
+	}
+	function noteRefusal(id) {
+		const clears = "use a taller text area or a shorter note line to clear this refusal.";
+		const found = blockForNote(id);
+		if (!found) return {
+			note: id,
+			message: `Note ${id} could not establish a fit for a note line in the text area; ${clears}`
+		};
+		const where = `chapter ${found.position.chapter} block ${found.position.block}`;
+		return {
+			tag: found.tag,
+			position: found.position,
+			message: `The ${found.tag} at ${where} could not establish a fit for a note line in the text area; ${clears}`
+		};
+	}
+	function lineTooTall(unit) {
+		return unit.bottom - unit.top > textHeight;
+	}
+	function greedyFill(placed, fragments, units, index) {
+		let next = index;
+		let notes = fragments;
+		while (next < units.length) {
+			const unit = units[next];
+			if (!unit || lineTooTall(unit)) break;
+			const allocated = paginateNotes(withNotes({
+				op: "allocate",
+				placed,
+				fragments: notes,
+				unit
+			}));
+			if (!allocated) break;
+			placed.push(unit);
+			notes = allocated;
+			next += 1;
+		}
+		return {
+			placed,
+			fragments: notes,
+			index: next
+		};
+	}
+	function forcePlace(unit) {
+		if (lineTooTall(unit)) return {
+			placed: [],
+			fragments: [],
+			index: 0,
+			pending: [],
+			refusal: refusal(unit.block)
+		};
+		const allocated = paginateNotes(withNotes({
+			op: "allocate",
+			placed: [],
+			fragments: [],
+			unit
+		}));
+		if (!allocated) return {
+			placed: [],
+			fragments: [],
+			index: 0,
+			pending: [],
+			refusal: refusal(unit.block)
+		};
+		return {
+			placed: [unit],
+			fragments: allocated,
+			index: 0,
+			pending: paginateNotes(withNotes({
+				op: "leftover",
+				fragments: allocated
+			}))
+		};
+	}
+	function fillPage(units, index, pending) {
+		const held = paginateNotes(withNotes({
+			op: "continue",
+			pending
+		}));
+		const incoming = units[index];
+		if (held.leftover.length === 0 && incoming && lineTooTall(incoming)) return {
+			placed: [],
+			fragments: [],
+			index,
+			pending,
+			refusal: refusal(incoming.block)
+		};
+		const stuck = held.fragments.length === 0 ? held.leftover[0] : void 0;
+		if (stuck) return {
+			placed: [],
+			fragments: [],
+			index,
+			pending: held.leftover,
+			refusal: noteRefusal(stuck.id)
+		};
+		if (held.leftover.length > 0) return {
+			placed: [],
+			fragments: held.fragments,
+			index,
+			pending: held.leftover
+		};
+		const filled = greedyFill([], held.fragments, units, index);
+		const placed = paginateKeeps(filled.placed, units[filled.index], textHeight, orphans, widows, held.fragments.length > 0);
+		const nextIndex = filled.index - (filled.placed.length - placed.length);
+		const fragments = paginateNotes(withNotes({
+			op: "recompute",
+			placed,
+			seed: held.fragments
+		}));
+		if (placed.length > 0 || fragments.length > 0) return {
+			placed,
+			fragments,
+			index: nextIndex,
+			pending: paginateNotes(withNotes({
+				op: "leftover",
+				fragments
+			}))
+		};
+		const unit = units[nextIndex];
+		const leftoverNote = pending[0];
+		if (!unit && leftoverNote) return {
+			placed: [],
+			fragments: [],
+			index: nextIndex,
+			pending,
+			refusal: noteRefusal(leftoverNote.id)
+		};
+		if (!unit) return {
+			placed: [],
+			fragments: [],
+			index: nextIndex,
+			pending,
+			done: true
+		};
+		const forced = forcePlace(unit);
+		if (forced.refusal) return forced;
+		return {
+			placed: forced.placed,
+			fragments: forced.fragments,
+			index: nextIndex + 1,
+			pending: forced.pending
+		};
+	}
+	return paginateSequence(input, fillPage);
+}
+const PAGINATE_FUNCTIONS = [
+	paginateColumns,
+	paginateNotes,
+	paginateKeeps,
+	paginateMarks,
+	paginateSequence,
+	paginateBook
+];
+function paginateScript() {
+	return `${PAGINATE_FUNCTIONS.map((fn) => fn.toString()).join("\n")}\nvar paginateBook=${paginateBook.name};`;
+}
+//#endregion
+export { PAGINATE_FUNCTIONS, paginateBook, paginateScript };

package/dist/book/paginate-columns.d.ts

@@ -0,0 +1,8 @@
+import { PaginateUnit, PaginateWindow } from "./paginate-types.js";
+//#region src/book/paginate-columns.d.ts
+export declare function paginateColumns(placed: PaginateUnit[]): {
+  windows: PaginateWindow[];
+  height: number;
+  headerRepeat: number;
+};
+//#endregion

package/dist/book/paginate-columns.js

@@ -0,0 +1,119 @@
+//#region src/book/paginate-columns.ts
+function paginateColumns(placed) {
+	function columnCount(block) {
+		return block.columns ?? 1;
+	}
+	function headerFor() {
+		const first = placed[0];
+		if (first?.block.kind !== "table" || first.index === 0) return 0;
+		return first.block.headerHeight ?? 0;
+	}
+	function sizes(count, columns) {
+		const base = Math.floor(count / columns);
+		const extra = count % columns;
+		return Array.from({ length: columns }, (_, index) => base + (index < extra ? 1 : 0));
+	}
+	function lineHeight(unit) {
+		return unit.bottom - unit.top;
+	}
+	function edgeStart(unit) {
+		return unit.prevBottom === void 0 ? unit.top : (unit.top + unit.prevBottom) / 2;
+	}
+	function edgeEnd(unit) {
+		return unit.nextTop === void 0 ? unit.bottom : (unit.bottom + unit.nextTop) / 2;
+	}
+	const headerRepeat = headerFor();
+	const windows = [];
+	let cursorBottom;
+	let cursorGalley;
+	let lowest = 0;
+	function beginY(index) {
+		const unit = placed[index];
+		if (!unit || cursorBottom === void 0 || cursorGalley === void 0) return 0;
+		return cursorBottom + (unit.top - cursorGalley);
+	}
+	function stack(from, to, startY) {
+		let y = startY;
+		let tallest = startY;
+		let lastBottom = startY;
+		for (let index = from; index < to; index += 1) {
+			const unit = placed[index];
+			const previous = index > from ? placed[index - 1] : void 0;
+			if (!unit) break;
+			if (previous) y += lineHeight(previous) + (unit.top - previous.bottom);
+			lastBottom = y + lineHeight(unit);
+			if (lastBottom > tallest) tallest = lastBottom;
+		}
+		return {
+			tallest,
+			lastBottom
+		};
+	}
+	function emit(from, to, startY, column, columns) {
+		const first = placed[from];
+		const last = placed[to - 1];
+		if (!first || !last) return;
+		const start = edgeStart(first);
+		windows.push({
+			flow: first.flowId,
+			start,
+			end: edgeEnd(last),
+			top: startY - (first.top - start) + headerRepeat,
+			column,
+			columns
+		});
+	}
+	function remember(bottom, last) {
+		cursorBottom = bottom;
+		if (last) cursorGalley = last.bottom;
+	}
+	function raise(height) {
+		if (height > lowest) lowest = height;
+	}
+	function layoutRun(from, to, columns) {
+		const startY = beginY(from);
+		if (columns <= 1) {
+			const laid = stack(from, to, startY);
+			emit(from, to, startY, 0, 1);
+			remember(laid.lastBottom, placed[to - 1]);
+			raise(laid.tallest);
+			return;
+		}
+		const parts = sizes(to - from, columns);
+		let offset = 0;
+		let tallest = startY;
+		for (let column = 0; column < columns; column += 1) {
+			const size = parts[column] ?? 0;
+			const start = from + offset;
+			const end = start + size;
+			offset += size;
+			if (size === 0) continue;
+			const laid = stack(start, end, startY);
+			emit(start, end, startY, column, columns);
+			if (laid.tallest > tallest) tallest = laid.tallest;
+		}
+		remember(tallest, placed[to - 1]);
+		raise(tallest);
+	}
+	let index = 0;
+	while (index < placed.length) {
+		const unit = placed[index];
+		if (!unit) break;
+		const columns = columnCount(unit.block);
+		let end = index + 1;
+		while (end < placed.length) {
+			const next = placed[end];
+			if (!next || columnCount(next.block) !== columns) break;
+			end += 1;
+		}
+		layoutRun(index, end, columns);
+		index = end;
+	}
+	return {
+		windows,
+		height: headerRepeat + lowest,
+		headerRepeat
+	};
+}
+//#endregion
+export { paginateColumns };

package/dist/book/paginate-keeps.d.ts

@@ -0,0 +1,4 @@
+import { PaginateUnit } from "./paginate-types.js";
+//#region src/book/paginate-keeps.d.ts
+export declare function paginateKeeps(placed: PaginateUnit[], next: PaginateUnit | undefined, textHeight: number, orphans: number, widows: number, allowEmpty?: boolean): PaginateUnit[];
+//#endregion

package/dist/book/paginate-keeps.js

@@ -0,0 +1,80 @@
+import { paginateColumns } from "./paginate-columns.js";
+//#region src/book/paginate-keeps.ts
+function paginateKeeps(placed, next, textHeight, orphans, widows, allowEmpty) {
+	function sameBlock(left, right) {
+		return left.position.chapter === right.position.chapter && left.position.block === right.position.block;
+	}
+	function countOf(held, block) {
+		let count = 0;
+		for (const unit of held) if (sameBlock(unit.block, block)) count += 1;
+		return count;
+	}
+	function dropBlock(held, block) {
+		return held.filter((unit) => !sameBlock(unit.block, block));
+	}
+	function kept(dropped) {
+		if (dropped.length > 0) return dropped;
+		return allowEmpty ? dropped : void 0;
+	}
+	function layoutHeight(block) {
+		const units = [];
+		for (const [index, line] of block.lines.entries()) units.push({
+			flowId: "",
+			block,
+			index,
+			top: line.top,
+			bottom: line.bottom,
+			refs: []
+		});
+		return paginateColumns(units).height;
+	}
+	function keepWithNext(block) {
+		return block.kind === "heading" || Boolean(block.keepWithNext);
+	}
+	function keepTogether(block) {
+		if (!(block.kind === "figure" || block.kind === "table" || Boolean(block.keepTogether))) return false;
+		return layoutHeight(block) <= textHeight;
+	}
+	function orphansOf(block) {
+		return block.orphans ?? orphans;
+	}
+	function widowsOf(block) {
+		return block.widows ?? widows;
+	}
+	function rewindTogether(held, last) {
+		if (!keepTogether(last.block) || countOf(held, last.block) >= last.block.lines.length) return void 0;
+		return kept(dropBlock(held, last.block));
+	}
+	function rewindOrphans(held, last) {
+		const block = last.block;
+		if (block.kind === "table") return void 0;
+		const heldCount = countOf(held, block);
+		if (!held.some((unit) => sameBlock(unit.block, block) && unit.index === 0) || heldCount >= block.lines.length || heldCount >= orphansOf(block)) return void 0;
+		return kept(dropBlock(held, block));
+	}
+	function rewindWidows(held, last) {
+		const block = last.block;
+		if (block.kind === "table") return void 0;
+		const remaining = block.lines.length - last.index - 1;
+		const needWidows = widowsOf(block);
+		if (remaining <= 0 || remaining >= needWidows) return void 0;
+		const need = needWidows - remaining;
+		return kept(countOf(held, block) - need <= 0 ? dropBlock(held, block) : held.slice(0, held.length - need));
+	}
+	function rewindHeading(held, last, following) {
+		const other = !following || !sameBlock(following.block, last.block);
+		if (!keepWithNext(last.block) || countOf(held, last.block) !== last.block.lines.length || !other) return void 0;
+		return kept(dropBlock(held, last.block));
+	}
+	let result = placed;
+	for (let pass = 0; pass < 8; pass += 1) {
+		const last = result[result.length - 1];
+		if (!last) return result;
+		const nextResult = rewindTogether(result, last) ?? rewindOrphans(result, last) ?? rewindWidows(result, last) ?? rewindHeading(result, last, next);
+		if (!nextResult) return result;
+		result = nextResult;
+	}
+	return result;
+}
+//#endregion
+export { paginateKeeps };

package/dist/book/paginate-marks.d.ts

@@ -0,0 +1,7 @@
+import { PaginatePageMarks, PaginateUnit } from "./paginate-types.js";
+//#region src/book/paginate-marks.d.ts
+export declare function paginateMarks(placed: PaginateUnit[], carried: PaginatePageMarks): {
+  marks: PaginatePageMarks;
+  carried: PaginatePageMarks;
+};
+//#endregion

package/dist/book/paginate-marks.js

@@ -0,0 +1,34 @@
+//#region src/book/paginate-marks.ts
+function paginateMarks(placed, carried) {
+	const onPage = Object.create(null);
+	for (const unit of placed) for (const mark of unit.block.marks ?? []) {
+		if (mark.line !== unit.index) continue;
+		const current = onPage[mark.name];
+		if (!current) onPage[mark.name] = {
+			first: mark.value,
+			last: mark.value
+		};
+		else current.last = mark.value;
+	}
+	const marks = Object.assign(Object.create(null), onPage);
+	for (const name of Object.keys(carried)) {
+		if (marks[name] !== void 0) continue;
+		const last = carried[name]?.last;
+		if (last === void 0) continue;
+		marks[name] = {
+			first: last,
+			last
+		};
+	}
+	const next = Object.assign(Object.create(null), carried);
+	for (const name of Object.keys(onPage)) {
+		const value = onPage[name];
+		if (value) next[name] = value;
+	}
+	return {
+		marks,
+		carried: next
+	};
+}
+//#endregion
+export { paginateMarks };

package/dist/book/paginate-notes.d.ts

@@ -0,0 +1,21 @@
+import { PaginateNotesOp, PaginatePageNote } from "./paginate-types.js";
+//#region src/book/paginate-notes.d.ts
+export declare function paginateNotes(payload: Extract<PaginateNotesOp, {
+  op: 'space';
+}>): number;
+export declare function paginateNotes(payload: Extract<PaginateNotesOp, {
+  op: 'continue';
+}>): {
+  fragments: PaginatePageNote[];
+  leftover: PaginatePageNote[];
+};
+export declare function paginateNotes(payload: Extract<PaginateNotesOp, {
+  op: 'allocate';
+}>): PaginatePageNote[] | undefined;
+export declare function paginateNotes(payload: Extract<PaginateNotesOp, {
+  op: 'recompute';
+}>): PaginatePageNote[];
+export declare function paginateNotes(payload: Extract<PaginateNotesOp, {
+  op: 'leftover';
+}>): PaginatePageNote[];
+//#endregion

package/dist/book/paginate-notes.js

@@ -0,0 +1,105 @@
+//#region src/book/paginate-notes.ts
+function paginateNotes(payload) {
+	const notesById = new Map(payload.notes.map((note) => [note.id, note]));
+	const notesGap = payload.geometry.notesGap;
+	const textHeight = payload.geometry.textHeight;
+	function noteEnd(id) {
+		return notesById.get(id)?.lines.length ?? 0;
+	}
+	function fragmentHeight(fragment) {
+		const note = notesById.get(fragment.id);
+		const start = note?.lines[fragment.start];
+		const end = note?.lines[fragment.end - 1];
+		return start && end ? end.bottom - start.top : 0;
+	}
+	function notesSpace(fragments) {
+		if (fragments.length === 0) return 0;
+		let height = 0;
+		for (const fragment of fragments) height += fragmentHeight(fragment);
+		return notesGap + height;
+	}
+	function measure(placed, fragments) {
+		if (payload.op === "continue" || payload.op === "allocate" || payload.op === "recompute") return payload.used(placed, fragments);
+		return notesSpace(fragments);
+	}
+	function makeFragment(id, start, end) {
+		return {
+			id,
+			whole: start === 0 && end === noteEnd(id),
+			start,
+			end
+		};
+	}
+	function leftoverFrom(fragments) {
+		return fragments.flatMap((fragment) => fragment.end < noteEnd(fragment.id) ? [makeFragment(fragment.id, fragment.end, noteEnd(fragment.id))] : []);
+	}
+	function takeContinued(continued) {
+		if (continued.length === 0) return {
+			fragments: [],
+			leftover: []
+		};
+		const fragments = [];
+		const leftover = [];
+		let pending = true;
+		for (const item of continued) {
+			const total = noteEnd(item.id);
+			if (!pending) {
+				leftover.push(item);
+				continue;
+			}
+			const whole = makeFragment(item.id, item.start, total);
+			if (measure([], [...fragments, whole]) <= textHeight) {
+				fragments.push(whole);
+				continue;
+			}
+			let end = item.start;
+			while (end < total && measure([], [...fragments, makeFragment(item.id, item.start, end + 1)]) <= textHeight) end += 1;
+			if (end > item.start) fragments.push(makeFragment(item.id, item.start, end));
+			if (end < total) leftover.push(makeFragment(item.id, end, total));
+			pending = false;
+		}
+		return {
+			fragments,
+			leftover
+		};
+	}
+	function fitNote(trial, fragments, id) {
+		const total = noteEnd(id);
+		if (total === 0) return void 0;
+		const whole = makeFragment(id, 0, total);
+		if (measure(trial, [...fragments, whole]) <= textHeight) return whole;
+		const minimum = Math.min(2, total);
+		if (measure(trial, [...fragments, makeFragment(id, 0, minimum)]) > textHeight) return void 0;
+		let end = minimum;
+		while (end < total && measure(trial, [...fragments, makeFragment(id, 0, end + 1)]) <= textHeight) end += 1;
+		return makeFragment(id, 0, end);
+	}
+	function allocateNotes(placed, existing, unit) {
+		const trial = [...placed, unit];
+		if (measure(trial, existing) > textHeight) return void 0;
+		const fragments = existing.slice();
+		for (const id of unit.refs) {
+			if (fragments.some((fragment) => fragment.id === id)) continue;
+			const fragment = fitNote(trial, fragments, id);
+			if (!fragment) return void 0;
+			fragments.push(fragment);
+		}
+		return fragments;
+	}
+	function notesFor(placed, seed) {
+		let fragments = seed;
+		for (const [offset, unit] of placed.entries()) {
+			const allocated = allocateNotes(placed.slice(0, offset), fragments, unit);
+			if (!allocated) break;
+			fragments = allocated;
+		}
+		return fragments;
+	}
+	if (payload.op === "space") return notesSpace(payload.fragments);
+	if (payload.op === "continue") return takeContinued(payload.pending);
+	if (payload.op === "allocate") return allocateNotes(payload.placed, payload.fragments, payload.unit);
+	if (payload.op === "recompute") return notesFor(payload.placed, payload.seed);
+	return leftoverFrom(payload.fragments);
+}
+//#endregion
+export { paginateNotes };

package/dist/book/paginate-sequence.d.ts

@@ -0,0 +1,4 @@
+import { PaginateBookInput, PaginateBookResult, PaginatePageFill, PaginatePageNote, PaginateUnit } from "./paginate-types.js";
+//#region src/book/paginate-sequence.d.ts
+export declare function paginateSequence(input: PaginateBookInput, fillPage: (units: PaginateUnit[], index: number, pending: PaginatePageNote[]) => PaginatePageFill): PaginateBookResult;
+//#endregion