app/lib/novels/export.ts

Functions

Imports

It imports app/lib/books.server.ts. Imported by app/routes/book.chapter.tsx, app/routes/book.export.ts.

Source

1// Assembly and export (design section 5, "for sending a book out"): ePub (zipped XHTML) and Word
2// built in the Worker, and PDF from the print page in the browser. Scenes are prose, so the Markdown
3// they use is small: paragraphs, headings, block quotes, scene breaks, *emphasis* and **strong**.
4// Anything else passes through as text rather than being guessed at.
5
6import { escapeHtml } from "@dustinedwards/site-runtime/html";
7import { AlignmentType, Document, HeadingLevel, Packer, PageBreak, Paragraph, TextRun } from "docx";
8import { strToU8, zipSync, type Zippable } from "fflate";
9
10import type { Assembled } from "~/lib/books.server";
11
12export type Inline = { text: string; em: boolean; strong: boolean };
13export type Block = { type: "p" | "quote"; inlines: Inline[] } | { type: "h"; level: number; inlines: Inline[] } | { type: "break" };
14
15/** `*a* **b** _c_ __d__`, with a backslash escaping the next character. Unclosed markers are text. */
16export function parseInline(text: string): Inline[] {
17  const out: Inline[] = [];
18  let em = false;
19  let strong = false;
20  let buf = "";
21  const flush = () => {
22    if (buf) out.push({ text: buf, em, strong });
23    buf = "";
24  };
25  // Markers that have a partner later in the line; the rest are literal.
26  const closes = (from: number, marker: string) => text.indexOf(marker, from) !== -1;
27  for (let i = 0; i < text.length; i++) {
28    const ch = text[i]!;
29    if (ch === "\\" && i + 1 < text.length) {
30      buf += text[++i];
31      continue;
32    }
33    if ((ch === "*" || ch === "_") && text[i + 1] === ch) {
34      const marker = ch + ch;
35      if (strong || closes(i + 2, marker)) {
36        flush();
37        strong = !strong;
38        i++;
39        continue;
40      }
41    } else if (ch === "*" || ch === "_") {
42      // An underscore inside a word (snake_case) is text.
43      const inWord = ch === "_" && /\w/.test(text[i - 1] ?? "") && /\w/.test(text[i + 1] ?? "");
44      if (!inWord && (em || closes(i + 1, ch))) {
45        flush();
46        em = !em;
47        continue;
48      }
49    }
50    buf += ch;
51  }
52  flush();
53  return out;
54}
55
56export function parseProse(body: string): Block[] {
57  const blocks: Block[] = [];
58  for (const chunk of body.replace(/\r\n/g, "\n").split(/\n\s*\n/)) {
59    const raw = chunk.trim();
60    if (!raw) continue;
61    if (/^(?:\*\s*){3,}$|^(?:-\s*){3,}$|^(?:_\s*){3,}$|^#$/.test(raw)) {
62      blocks.push({ type: "break" });
63      continue;
64    }
65    const heading = /^(#{1,6})\s+(.*)$/.exec(raw);
66    if (heading && !raw.includes("\n")) {
67      blocks.push({ type: "h", level: heading[1]!.length, inlines: parseInline(heading[2]!.trim()) });
68      continue;
69    }
70    if (raw.split("\n").every((l) => l.startsWith(">"))) {
71      const text = raw.split("\n").map((l) => l.replace(/^>\s?/, "")).join(" ");
72      blocks.push({ type: "quote", inlines: parseInline(text) });
73      continue;
74    }
75    // Hard wraps inside a paragraph are one paragraph; a line ending in two spaces is not kept.
76    blocks.push({ type: "p", inlines: parseInline(raw.split("\n").map((l) => l.trim()).join(" ")) });
77  }
78  return blocks;
79}
80
81// ---------- XHTML, for ePub and the print page
82
83function inlineHtml(inlines: Inline[]): string {
84  return inlines
85    .map((i) => {
86      let html = escapeHtml(i.text);
87      if (i.em) html = `<em>${html}</em>`;
88      if (i.strong) html = `<strong>${html}</strong>`;
89      return html;
90    })
91    .join("");
92}
93
94export function blocksToHtml(blocks: Block[]): string {
95  return blocks
96    .map((b) => {
97      switch (b.type) {
98        case "break":
99          return `<p class="scene-break">* * *</p>`;
100        case "h": {
101          // Chapter titles are h1 in the assembled book, so a heading inside a scene sits below them.
102          const level = Math.min(6, b.level + 1);
103          return `<h${level}>${inlineHtml(b.inlines)}</h${level}>`;
104        }
105        case "quote":
106          return `<blockquote><p>${inlineHtml(b.inlines)}</p></blockquote>`;
107        default:
108          return `<p>${inlineHtml(b.inlines)}</p>`;
109      }
110    })
111    .join("\n");
112}
113
114/** A chapter's scenes, separated by scene breaks, as the chapter's body. */
115function chapterBlocks(chapter: Assembled["chapters"][number]): Block[] {
116  const out: Block[] = [];
117  chapter.scenes.forEach((scene, i) => {
118    if (i > 0) out.push({ type: "break" });
119    out.push(...parseProse(scene.body));
120  });
121  return out;
122}
123
124const BOOK_CSS = `body { font-family: Georgia, "Times New Roman", serif; line-height: 1.5; }
125h1 { text-align: center; margin: 3em 0 2em; font-weight: normal; }
126p { margin: 0; text-indent: 1.5em; }
127h1 + p, h2 + p, .scene-break + p, blockquote + p { text-indent: 0; }
128.scene-break { text-align: center; text-indent: 0; margin: 1em 0; }
129blockquote { margin: 1em 2em; font-style: italic; }
130`;
131
132// ---------- ePub 3
133
134export function slugFor(title: string): string {
135  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "book";
136}
137
138export function buildEpub(book: Assembled, opts: { id: string; modified: Date }): Uint8Array<ArrayBuffer> {
139  const chapterFiles = book.chapters.map((c, i) => ({ file: `chapter-${String(i + 1).padStart(3, "0")}.xhtml`, chapter: c }));
140  const xhtml = (title: string, body: string) =>
141    `<?xml version="1.0" encoding="UTF-8"?>
142<!DOCTYPE html>
143<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="${escapeHtml(book.language)}" xml:lang="${escapeHtml(book.language)}">
144<head><meta charset="UTF-8"/><title>${escapeHtml(title)}</title><link rel="stylesheet" type="text/css" href="book.css"/></head>
145<body>
146${body}
147</body>
148</html>
149`;
150  const modified = opts.modified.toISOString().replace(/\.\d{3}Z$/, "Z");
151  const opf = `<?xml version="1.0" encoding="UTF-8"?>
152<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="book-id" xml:lang="${escapeHtml(book.language)}">
153  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
154    <dc:identifier id="book-id">urn:uuid:${escapeHtml(opts.id)}</dc:identifier>
155    <dc:title>${escapeHtml(book.title)}</dc:title>
156    <dc:creator>${escapeHtml(book.author)}</dc:creator>
157    <dc:language>${escapeHtml(book.language)}</dc:language>
158    <meta property="dcterms:modified">${modified}</meta>
159  </metadata>
160  <manifest>
161    <item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>
162    <item id="css" href="book.css" media-type="text/css"/>
163    <item id="title" href="title.xhtml" media-type="application/xhtml+xml"/>
164${chapterFiles.map((c, i) => `    <item id="c${i + 1}" href="${c.file}" media-type="application/xhtml+xml"/>`).join("\n")}
165  </manifest>
166  <spine>
167    <itemref idref="title"/>
168${chapterFiles.map((_, i) => `    <itemref idref="c${i + 1}"/>`).join("\n")}
169  </spine>
170</package>
171`;
172  const nav = xhtml(
173    book.title,
174    `<nav epub:type="toc" id="toc"><h1>Contents</h1><ol>
175${chapterFiles.map((c) => `<li><a href="${c.file}">${escapeHtml(c.chapter.title)}</a></li>`).join("\n")}
176</ol></nav>`,
177  );
178  const files: Zippable = {
179    // The mimetype comes first and uncompressed, as the ePub container requires.
180    mimetype: [strToU8("application/epub+zip"), { level: 0 }],
181    "META-INF/container.xml": strToU8(`<?xml version="1.0" encoding="UTF-8"?>
182<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
183  <rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles>
184</container>
185`),
186    "OEBPS/content.opf": strToU8(opf),
187    "OEBPS/nav.xhtml": strToU8(nav),
188    "OEBPS/book.css": strToU8(BOOK_CSS),
189    "OEBPS/title.xhtml": strToU8(xhtml(book.title, `<h1>${escapeHtml(book.title)}</h1>\n<p class="scene-break">${escapeHtml(book.author)}</p>`)),
190  };
191  for (const c of chapterFiles) {
192    files[`OEBPS/${c.file}`] = strToU8(xhtml(c.chapter.title, `<h1>${escapeHtml(c.chapter.title)}</h1>\n${blocksToHtml(chapterBlocks(c.chapter))}`));
193  }
194  // Copied into an ArrayBuffer-backed array, which a Response body requires.
195  return new Uint8Array(zipSync(files));
196}
197
198// ---------- Word
199
200function runs(inlines: Inline[]): TextRun[] {
201  return inlines.map((i) => new TextRun({ text: i.text, italics: i.em, bold: i.strong }));
202}
203
204export async function buildDocx(book: Assembled): Promise<ArrayBuffer> {
205  const children: Paragraph[] = [
206    new Paragraph({ heading: HeadingLevel.TITLE, alignment: AlignmentType.CENTER, children: [new TextRun(book.title)] }),
207    new Paragraph({ alignment: AlignmentType.CENTER, children: [new TextRun(book.author)] }),
208  ];
209  for (const chapter of book.chapters) {
210    children.push(new Paragraph({ children: [new PageBreak()] }));
211    children.push(new Paragraph({ heading: HeadingLevel.HEADING_1, alignment: AlignmentType.CENTER, children: [new TextRun(chapter.title)] }));
212    for (const b of chapterBlocks(chapter)) {
213      if (b.type === "break") children.push(new Paragraph({ alignment: AlignmentType.CENTER, children: [new TextRun("* * *")] }));
214      else if (b.type === "h") children.push(new Paragraph({ heading: b.level <= 1 ? HeadingLevel.HEADING_2 : HeadingLevel.HEADING_3, children: runs(b.inlines) }));
215      else if (b.type === "quote") children.push(new Paragraph({ indent: { left: 720, right: 720 }, children: runs(b.inlines) }));
216      else children.push(new Paragraph({ indent: { firstLine: 360 }, children: runs(b.inlines) }));
217    }
218  }
219  const doc = new Document({ creator: book.author, title: book.title, sections: [{ children }] });
220  return Packer.toArrayBuffer(doc);
221}
222
223// ---------- the print page, for PDF from the browser
224
225export function printHtml(book: Assembled): string {
226  const chapters = book.chapters
227    .map((c) => `<section class="chapter"><h1>${escapeHtml(c.title)}</h1>\n${blocksToHtml(chapterBlocks(c))}</section>`)
228    .join("\n");
229  return `<!doctype html>
230<html lang="${escapeHtml(book.language)}">
231<head>
232<meta charset="utf-8">
233<meta name="viewport" content="width=device-width, initial-scale=1">
234<title>${escapeHtml(book.title)}</title>
235<style>
236${BOOK_CSS}
237body { max-width: 34rem; margin: 2rem auto; padding: 0 1rem; font-size: 12pt; }
238.title-page { text-align: center; margin: 30vh 0; }
239.chapter { break-before: page; }
240.hint { font-family: system-ui, sans-serif; font-size: 10pt; color: #555; border: 1px solid #ccc; padding: 0.5rem 0.75rem; }
241@page { size: 6in 9in; margin: 0.75in; }
242@media print { .hint { display: none; } body { margin: 0; max-width: none; } }
243</style>
244</head>
245<body>
246<p class="hint">Print this page and choose Save as PDF. The page size is 6 by 9 inches.</p>
247<section class="title-page"><h1>${escapeHtml(book.title)}</h1><p class="scene-break">${escapeHtml(book.author)}</p></section>
248${chapters}
249</body>
250</html>
251`;
252}