paperlint 6.3.0 → 7.1.0

package/src/domain/body-pages.test.ts

@@ -3,6 +3,8 @@ import {
   bodyEnd,
   isAppendixHeading,
   isReferencesHeading,
+  pageSplit,
+  type Anchors,
 } from "./body-pages.ts";
 
 describe("isReferencesHeading", () => {
@@ -298,3 +300,145 @@ describe("bodyEnd: where the appendix is not taken, or not found", () => {
     });
   });
 });
+
+describe("pageSplit: the appendix counts as body, the reference pages are the ones holding only references", () => {
+  it("no appendix: the body up to the references, the rest references", () => {
+    expect(
+      pageSplit(["body", "end\nReferences\n[1] A.", "[2] B.", "[3] C."], {
+        bib: 2,
+        appendix: null,
+      }),
+    ).toEqual({
+      kind: "found",
+      page: 2,
+      bodyPages: 2,
+      refPages: 2,
+      appendixFrom: null,
+    });
+  });
+
+  it("🔴 an appendix before the references is body: it does not end the body", () => {
+    expect(
+      pageSplit(
+        [
+          "body",
+          "Appendix A.\nDetails",
+          "more details\nReferences\n[1] A.",
+          "[2] B.",
+        ],
+        { bib: 3, appendix: 2 },
+      ),
+    ).toEqual({
+      kind: "found",
+      page: 3,
+      bodyPages: 3,
+      refPages: 1,
+      appendixFrom: null,
+    });
+  });
+
+  it("🔴 an appendix after the references is body: the pages from it to the end", () => {
+    expect(
+      pageSplit(
+        [
+          "body",
+          "end\nReferences\n[1] A.",
+          "[2] B.",
+          "[3] C.\nAppendix A.\nx",
+          "y",
+        ],
+        { bib: 2, appendix: 4 },
+      ),
+    ).toEqual({
+      kind: "found",
+      page: 2,
+      bodyPages: 4,
+      refPages: 1,
+      appendixFrom: 4,
+    });
+  });
+});
+
+describe("pageSplit: the appendix and the references on one page", () => {
+  it("an appendix after the references on their own page: that page is counted once", () => {
+    expect(
+      pageSplit(["body", "end\nReferences\n[1] A.\nAppendix A.\nx"], {
+        bib: 2,
+        appendix: 2,
+      }),
+    ).toEqual({
+      kind: "found",
+      page: 2,
+      bodyPages: 2,
+      refPages: 0,
+      appendixFrom: 2,
+    });
+  });
+
+  it("an appendix above the references on their page is body before them, like any text", () => {
+    expect(
+      pageSplit(["body", "end\nAppendix A.\nx\nReferences\n[1] A.", "[2] B."], {
+        bib: 2,
+        appendix: 2,
+      }),
+    ).toEqual({
+      kind: "found",
+      page: 2,
+      bodyPages: 2,
+      refPages: 1,
+      appendixFrom: null,
+    });
+  });
+
+  it("the references at the top of their page: that page holds only references", () => {
+    expect(
+      pageSplit(["body", "References\n[1] A.", "Appendix A.\nx"], {
+        bib: 2,
+        appendix: 3,
+      }),
+    ).toEqual({
+      kind: "found",
+      page: 2,
+      bodyPages: 2,
+      refPages: 1,
+      appendixFrom: 3,
+    });
+  });
+});
+
+describe("pageSplit: what is said rather than counted, and what is not looked for", () => {
+  it.each<[string, readonly string[], Anchors, string]>([
+    [
+      "no references heading",
+      ["body", "Appendix\nx"],
+      { bib: null, appendix: 2 },
+      "missing",
+    ],
+    [
+      "an appendix anchor with no heading",
+      ["body", "References\n[1] A.", "x"],
+      { bib: 2, appendix: 3 },
+      "disagree",
+    ],
+    [
+      "a references anchor with no heading",
+      ["body", "x"],
+      { bib: 2, appendix: null },
+      "disagree",
+    ],
+  ])("%s: said, not counted", (_, pages, anchors, kind) => {
+    expect(pageSplit(pages, anchors).kind).toBe(kind);
+  });
+
+  it("without anchors the references heading is found in the text, and no appendix is looked for", () => {
+    expect(
+      pageSplit(["body", "end\nReferences\n[1] A.", "Appendix A.\nx"]),
+    ).toEqual({
+      kind: "found",
+      page: 2,
+      bodyPages: 2,
+      refPages: 1,
+      appendixFrom: null,
+    });
+  });
+});

package/src/domain/body-pages.ts

@@ -186,8 +186,11 @@ function appendixAt(
       };
 }
 
+/** A body end that was found. */
+type Found = Extract<BodyEnd, { readonly kind: "found" }>;
+
 /** The body's end at a heading: the heading's page counts when body text stands above it. */
-function endAt(pages: readonly PageReading[], at: At): BodyEnd {
+function endAt(pages: readonly PageReading[], at: At): Found {
   const running = runningLines(pages);
   const body = at.above.some((l) => /\p{L}/u.test(l) && !running.has(shape(l)));
   return {
@@ -221,3 +224,60 @@ export function bodyEnd(
     .toSorted((a, b) => a.page - b.page || a.line - b.line)[0];
   return first === undefined ? { kind: "missing" } : endAt(pages, first);
 }
+
+/**
+ * The pages of a paper split as a venue counts them when its body limit includes the appendices
+ * and only the pages holding nothing but references are reference pages (MSR: «10 pages for the
+ * main text, inclusive of all figures, tables, appendices, etc. Two more pages containing only
+ * references are permitted.»):
+ *
+ *   body        the pages up to the references — their page too when body text stands above the
+ *               heading — and, when the appendix starts after the references, every page from the
+ *               appendix's to the last, which holds appendix text
+ *   references  the pages between, which hold only references
+ *
+ * An appendix before the references is body like any other text, and ends nothing. The appendix is
+ * found by hyperref's anchor only (`appendixAt`): without hyperref, an appendix after the references
+ * is not told from them and is counted with them. Pure.
+ */
+export type PageSplit =
+  | {
+      readonly kind: "found";
+      /** 1-based page holding the references heading. */
+      readonly page: number;
+      readonly bodyPages: number;
+      readonly refPages: number;
+      /** 1-based page the appendix starts on, when it follows the references; else null. */
+      readonly appendixFrom: number | null;
+    }
+  | { readonly kind: "missing" }
+  | Extract<BodyEnd, { readonly kind: "disagree" }>;
+
+/** Whether heading `a` stands after heading `b` in the document. */
+const after = (a: At, b: At): boolean =>
+  a.page > b.page || (a.page === b.page && a.line > b.line);
+
+export function pageSplit(
+  texts: readonly string[],
+  anchors: Anchors = { bib: null, appendix: null },
+): PageSplit {
+  const pages = texts.map(readPage);
+  const refs = referencesAt(pages, anchors.bib);
+  const appendix = appendixAt(pages, anchors.appendix);
+  if (refs.kind === "disagree") return refs;
+  if (appendix.kind === "disagree") return appendix;
+  if (refs.kind === "missing") return { kind: "missing" };
+  const upTo = endAt(pages, refs).bodyPages;
+  const tail =
+    appendix.kind === "at" && after(appendix, refs) ? appendix.page : null;
+  // The pages from the appendix to the end, less the ones already counted up to the references.
+  const appendixPages = tail === null ? 0 : pages.length - Math.max(tail, upTo);
+  const bodyPages = upTo + appendixPages;
+  return {
+    kind: "found",
+    page: refs.page + 1,
+    bodyPages,
+    refPages: pages.length - bodyPages,
+    appendixFrom: tail === null ? null : tail + 1,
+  };
+}