@open-press/core 0.3.0

package/engine/page-renderer.mjs

@@ -0,0 +1,217 @@
+const TOC_ENTRIES_PER_PAGE = 24;
+
+function renderPageShell(sectionClass, bodyHtml, attrs = "", { kind, footer = true } = {}) {
+  const className = footer === false ? addClass(sectionClass, "no-footer") : sectionClass;
+  const attrsPart = pageAttrs(attrs, { kind, footer });
+  const footerHtml = footer === false ? "" : `
+    <footer class="page-footer" aria-hidden="true"></footer>`;
+  return `<section class="${className}"${attrsPart}>
+  <div class="page-frame">
+    <header class="page-header" aria-hidden="true"></header>
+    <main class="page-body">
+${bodyHtml.trim()}
+    </main>${footerHtml}
+  </div>
+</section>`;
+}
+
+export function renderToc({ title, items, className } = {}) {
+  const headingText = typeof title === "string" && title.trim() ? title.trim() : "Contents";
+  const tocItems = Array.isArray(items) ? items : [];
+  const tocChunks = tocItems.length > 0 ? chunkArray(tocItems, TOC_ENTRIES_PER_PAGE) : [[]];
+
+  return tocChunks.map((chunk, pageIndex) => {
+    const isContinuation = pageIndex > 0;
+    const pageId = pageIndex === 0 ? "toc" : `toc-${String(pageIndex + 1).padStart(2, "0")}`;
+    const headingId = pageIndex === 0 ? "toc-title" : `${pageId}-title`;
+    const pageHeadingText = isContinuation ? tocContinuationTitle(headingText) : headingText;
+    const headingClass = isContinuation ? ` class="toc-heading toc-heading--continuation"` : ` class="toc-heading"`;
+    const tocList = chunk.length > 0
+      ? `
+  <ol class="toc-list">
+${chunk.map((item, index) => {
+  const level = item.level === 3 ? 3 : 2;
+  const absoluteIndex = pageIndex * TOC_ENTRIES_PER_PAGE + index;
+  const label = item.label || (level === 2 ? `#${absoluteIndex + 1}` : "");
+  const targetPageIndex = Math.max(0, Number(item.pageNumber || 1) - 1);
+  return `    <li class="toc-level-${level}"><a href="#${escapeAttr(item.id)}" data-openpress-anchor="${escapeAttr(item.id)}" data-openpress-target-page-index="${targetPageIndex}"><span class="toc-index" data-toc-index="${escapeAttr(label)}">${escapeHtml(label)}</span><span class="toc-title">${escapeHtml(item.title)}</span><span class="toc-page">${String(item.pageNumber).padStart(2, "0")}</span></a></li>`;
+}).join("\n")}
+  </ol>
+`
+      : "";
+    return renderPageShell(
+      tocPageClassName(className, isContinuation),
+      `
+  <h2 id="${headingId}"${headingClass}>${escapeHtml(pageHeadingText)}</h2>
+${tocList}
+`,
+      [
+        `id="${pageId}"`,
+        `data-page-title="${escapeAttr(headingText)}"`,
+        `data-toc-continuation="${isContinuation ? "true" : "false"}"`,
+        `aria-labelledby="${headingId}"`,
+      ].filter(Boolean).join(" "),
+      { kind: "toc", footer: false },
+    );
+  }).join("\n\n");
+}
+
+function tocContinuationTitle(title) {
+  return title === "目錄" ? "目錄續" : `${title} continued`;
+}
+
+function pageAttrs(attrs, { kind, footer } = {}) {
+  const parts = [];
+  if (attrs.trim()) parts.push(attrs.trim());
+  if (kind && !hasAttr(attrs, "data-page-kind")) parts.push(`data-page-kind="${escapeAttr(kind)}"`);
+  if (footer === false && !hasAttr(attrs, "data-page-footer")) parts.push('data-page-footer="false"');
+  return parts.length ? ` ${parts.join(" ")}` : "";
+}
+
+function hasAttr(attrs, name) {
+  return new RegExp(`\\b${name}=`).test(attrs);
+}
+
+function addClass(className, extraClass) {
+  const classes = className.split(/\s+/).filter(Boolean);
+  if (!classes.includes(extraClass)) classes.push(extraClass);
+  return classes.join(" ");
+}
+
+export function injectStaticToc(pages) {
+  const tocItems = collectTocItems(pages);
+  if (tocItems.length === 0) return pages;
+  const tocIndex = pages.findIndex((page) => hasPageKind(page.match(/^<section[^>]*>/i)?.[0] ?? "", "toc"));
+  const tocPageCount = Math.max(1, Math.ceil(tocItems.length / TOC_ENTRIES_PER_PAGE));
+  const tocPageNumber = tocIndex + 1;
+  const adjustedTocItems = tocPageCount > 1 && tocIndex >= 0
+    ? tocItems.map((item) => ({
+      ...item,
+      pageNumber: item.pageNumber > tocPageNumber ? item.pageNumber + tocPageCount - 1 : item.pageNumber,
+    }))
+    : tocItems;
+
+  return pages.map((page) => {
+    const openingTag = page.match(/^<section[^>]*>/i)?.[0] ?? "";
+    if (!hasPageKind(openingTag, "toc")) return page;
+    const title = extractAttr(openingTag, "data-page-title");
+    return renderToc({ title, items: adjustedTocItems, className: extractAttr(openingTag, "class") });
+  });
+}
+
+function tocPageClassName(className, isContinuation) {
+  const classes = new Set(String(className || "reader-page reader-page--toc").split(/\s+/).filter(Boolean));
+  classes.delete("toc");
+  classes.add("reader-page");
+  classes.add("reader-page--toc");
+  if (isContinuation) classes.add("toc-continuation");
+  else classes.delete("toc-continuation");
+  return [...classes].join(" ");
+}
+
+function extractAttr(openingTag, name) {
+  const re = new RegExp(`${name}="([^"]*)"`);
+  return openingTag.match(re)?.[1];
+}
+
+function collectTocItems(pages) {
+  const items = [];
+  let chapterIndex = 0;
+  let sectionIndex = 0;
+  let pendingChapterOpener;
+
+  pages.forEach((page, index) => {
+    const openingTag = page.match(/^<section[^>]*>/i)?.[0] ?? "";
+    if (hasPageKind(openingTag, "chapter-opener")) {
+      pendingChapterOpener = extractChapterOpenerTarget(page, index);
+      return;
+    }
+
+    if (!hasContentPageKind(openingTag)) return;
+
+    let pageStartedChapter = false;
+    const headings = [...page.matchAll(/<h([23])\b[^>]*\bid="([^"]+)"[^>]*>([\s\S]*?)<\/h\1>/gi)];
+    headings.forEach((heading) => {
+      const level = Number(heading[1]);
+      if (level === 2) {
+        const opener = pendingChapterOpener;
+        pendingChapterOpener = undefined;
+        pageStartedChapter = true;
+        chapterIndex += 1;
+        sectionIndex = 0;
+        items.push({
+          id: opener?.id ?? heading[2],
+          title: htmlToText(heading[3]),
+          pageNumber: opener?.pageNumber ?? index + 1,
+          level: 2,
+          label: `#${chapterIndex}`,
+        });
+        return;
+      }
+
+      if (level === 3 && chapterIndex > 0) {
+        sectionIndex += 1;
+        items.push({
+          id: heading[2],
+          title: htmlToText(heading[3]),
+          pageNumber: index + 1,
+          level: 3,
+          label: `${chapterIndex}.${sectionIndex}`,
+        });
+      }
+    });
+    if (!pageStartedChapter) pendingChapterOpener = undefined;
+  });
+  return items;
+}
+
+function extractChapterOpenerTarget(page, index) {
+  const heading = page.match(/<h2\b[^>]*\bid="([^"]+)"[^>]*>([\s\S]*?)<\/h2>/i);
+  if (!heading?.[1]) return undefined;
+  return {
+    id: heading[1],
+    pageNumber: index + 1,
+  };
+}
+
+function htmlToText(html) {
+  return html
+    .replace(/<[^>]+>/g, "")
+    .replaceAll("&nbsp;", " ")
+    .replaceAll("&amp;", "&")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&quot;", '"')
+    .trim();
+}
+
+function hasPageKind(openingTag, kind) {
+  return extractAttr(openingTag, "data-page-kind") === kind;
+}
+
+function hasContentPageKind(openingTag) {
+  return extractAttr(openingTag, "data-page-kind") === "content";
+}
+
+function escapeAttr(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
+function chunkArray(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}

package/engine/pdf-media.mjs

@@ -0,0 +1,45 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+export async function optimizePdfMediaForStaticRoot(staticRoot) {
+  await optimizePdfMedia(path.join(staticRoot, "openpress", "media"));
+}
+
+async function optimizePdfMedia(mediaDir) {
+  const files = await listImageFiles(mediaDir);
+  for (const file of files) {
+    const stat = await fs.stat(file);
+    if (stat.size < 320 * 1024) continue;
+
+    const ext = path.extname(file).toLowerCase();
+    const args =
+      ext === ".jpg" || ext === ".jpeg"
+        ? ["-Z", "1600", "--setProperty", "formatOptions", "78", file, "--out", file]
+        : ["-Z", "1600", file, "--out", file];
+    const result = spawnSync("sips", args, { stdio: "ignore" });
+    if (result.status !== 0) {
+      console.warn(`[pdf] skipped image optimization: ${path.basename(file)}`);
+    }
+  }
+}
+
+async function listImageFiles(dir) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await listImageFiles(fullPath)));
+    } else if (/\.(jpe?g|png)$/i.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}

package/engine/public-assets.mjs

@@ -0,0 +1,19 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "./config.mjs";
+import { copyDirectory, writeComponentsCss, writeContentCss } from "./file-utils.mjs";
+import { copyThemeFonts } from "./fonts.mjs";
+import { copyKatexFonts } from "./katex-assets.mjs";
+
+export async function syncPublicAssets(root, publicOutputDir, config) {
+  config ??= await loadConfig(root);
+  await fs.rm(path.join(publicOutputDir, "report.css"), { force: true });
+  for (const name of ["tokens.css"]) {
+    await fs.copyFile(path.join(config.paths.themeDir, name), path.join(publicOutputDir, name));
+  }
+  await writeContentCss(root, publicOutputDir, config);
+  await copyThemeFonts(root, publicOutputDir, config);
+  await copyKatexFonts(publicOutputDir);
+  await writeComponentsCss(root, publicOutputDir, config);
+  await copyDirectory(config.paths.mediaDir, path.join(publicOutputDir, "media"));
+}

package/engine/react/chapter-css.mjs

@@ -0,0 +1,53 @@
+import fs from "node:fs/promises";
+import postcss from "postcss";
+
+const UNSCOPED_RULE_PARENTS = new Set(["keyframes", "-webkit-keyframes", "page"]);
+
+export async function buildChapterScopedCss(workspace) {
+  const parts = [];
+  for (const chapter of workspace.chapters ?? []) {
+    for (const styleFile of chapter.styleFiles ?? []) {
+      const source = await fs.readFile(styleFile.absolutePath, "utf8");
+      const scoped = await scopeChapterCss(source, {
+        chapterSlug: chapter.slug,
+        from: styleFile.absolutePath,
+      });
+      if (!scoped.trim()) continue;
+      parts.push(`/* === ${styleFile.documentPath} === */`);
+      parts.push(scoped.trimEnd());
+      parts.push("");
+    }
+  }
+  return parts.join("\n");
+}
+
+export async function scopeChapterCss(source, { chapterSlug, from = undefined } = {}) {
+  if (typeof source !== "string") throw new Error("scopeChapterCss requires a CSS source string.");
+  const slug = cssAttributeValue(chapterSlug);
+  const scope = `[data-chapter-slug="${slug}"]`;
+  const root = postcss.parse(source, { from });
+
+  root.walkRules((rule) => {
+    if (isInsideUnscopedAtRule(rule)) return;
+    rule.selector = `${scope} :where(${rule.selector})`;
+  });
+
+  return root.toString();
+}
+
+function isInsideUnscopedAtRule(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "atrule" && UNSCOPED_RULE_PARENTS.has(current.name.toLowerCase())) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+function cssAttributeValue(value) {
+  return String(value ?? "")
+    .replaceAll("\\", "\\\\")
+    .replaceAll('"', '\\"');
+}

package/engine/react/comment-endpoint.d.mts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+export function handleCommentRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  options?: {
+    root?: string;
+    id?: string;
+    timestamp?: string;
+  },
+): Promise<void>;

package/engine/react/comment-endpoint.mjs

@@ -0,0 +1,128 @@
+import {
+  clearCommentMarkers,
+  insertCommentMarker,
+  listCommentMarkers,
+  updateCommentMarker,
+} from "./comment-marker.mjs";
+
+const MAX_COMMENT_BODY_BYTES = 64 * 1024;
+
+export async function handleCommentRequest(req, res, {
+  root = ".",
+  id = undefined,
+  timestamp = undefined,
+} = {}) {
+  if (req.method === "GET") {
+    try {
+      writeJson(res, 200, { ok: true, comments: await listCommentMarkers({ root }) });
+    } catch (error) {
+      writeJson(res, 400, {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return;
+  }
+
+  if (req.method === "DELETE") {
+    try {
+      const body = await readJsonBody(req);
+      const result = await clearCommentMarkers({
+        root,
+        id: body?.id,
+        all: body?.all === true,
+      });
+      writeJson(res, 200, { ok: true, ...result });
+    } catch (error) {
+      writeJson(res, 400, {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return;
+  }
+
+  if (req.method === "PATCH") {
+    try {
+      const body = await readJsonBody(req);
+      const result = await updateCommentMarker({
+        root,
+        id: body?.id,
+        note: body?.note,
+        hint: body?.hint,
+        timestamp,
+      });
+      writeJson(res, 200, {
+        ok: true,
+        comment: {
+          id: result.id,
+          timestamp: result.timestamp,
+          path: result.path,
+          line: result.line,
+          note: result.note,
+          hint: result.hint,
+        },
+      });
+    } catch (error) {
+      writeJson(res, 400, {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return;
+  }
+
+  if (req.method !== "POST") {
+    writeJson(res, 405, { ok: false, message: "OpenPress comment endpoint requires GET, POST, PATCH, or DELETE." });
+    return;
+  }
+
+  try {
+    const body = await readJsonBody(req);
+    const target = body?.target ?? {};
+    const result = await insertCommentMarker({
+      root,
+      path: target.path ?? body?.path,
+      source: target.source ?? body?.source,
+      note: body?.note,
+      hint: body?.hint,
+      id,
+      timestamp,
+    });
+
+    writeJson(res, 200, {
+      ok: true,
+      comment: {
+        id: result.id,
+        timestamp: result.timestamp,
+        path: result.path,
+        line: result.line,
+      },
+    });
+  } catch (error) {
+    writeJson(res, 400, {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+async function readJsonBody(req) {
+  let body = "";
+  for await (const chunk of req) {
+    body += String(chunk);
+    if (Buffer.byteLength(body, "utf8") > MAX_COMMENT_BODY_BYTES) {
+      throw new Error("OpenPress comment request body is too large.");
+    }
+  }
+  try {
+    return JSON.parse(body || "{}");
+  } catch {
+    throw new Error("OpenPress comment request body must be valid JSON.");
+  }
+}
+
+function writeJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(`${JSON.stringify(body, null, 2)}\n`);
+}