Break Up LaTeX Source on Section Macros

packages/unified-latex-to-pretext/libs/break-on-boundaries.ts

@@ -0,0 +1,114 @@
+import { env, m } from "@unified-latex/unified-latex-builder";
+import * as Ast from "@unified-latex/unified-latex-types";
+import { getNamedArgsContent } from "@unified-latex/unified-latex-util-arguments";
+import {
+    anyEnvironment,
+    anyMacro,
+    match,
+} from "@unified-latex/unified-latex-util-match";
+import { replaceNode } from "@unified-latex/unified-latex-util-replace";
+import {
+    splitOnMacro,
+    unsplitOnMacro,
+} from "@unified-latex/unified-latex-util-split";
+import { visit } from "@unified-latex/unified-latex-util-visit";
+
+/**
+ * Breaks up division macros into environments
+ */
+export function breakOnBoundaries(ast: Ast.Ast): void {
+    const divisions = [
+        "part",
+        "chapter",
+        "section",
+        "subsection",
+        "subsubsection",
+        "paragraph",
+        "subparagraph",
+    ];
+
+    const new_boundaries = [
+        "_part",
+        "_chapter",
+        "_section",
+        "_subsection",
+        "_subsubsection",
+        "_paragraph",
+        "_subparagraph",
+    ];
+
+    visit(ast, (node, info) => {
+        // needs to be an environment, root, or group node
+        if (
+            !(
+                anyEnvironment(node) ||
+                node.type === "root" ||
+                match.group(node)
+            ) ||
+            info.context.hasMathModeAncestor
+        ) {
+            return;
+        }
+
+        // if it's an environment, make sure it isn't a newly created one
+        else if (anyEnvironment(node) && new_boundaries.includes(node.env)) {
+            return;
+        }
+
+        // now break up the divisions, starting at part
+        node.content = breakUp(node.content, divisions, 0);
+    });
+
+    // remove all old division nodes
+    replaceNode(ast, (node) => {
+        if (anyMacro(node) && divisions.includes(node.content)) {
+            return null;
+        }
+    });
+}
+
+function breakUp(
+    content: Ast.Node[],
+    divisions: string[],
+    index: number
+): Ast.Node[] {
+    // broke up all divisions
+    if (index > 6) {
+        return content;
+    }
+
+    const splits = splitOnMacro(content, divisions[index]);
+
+    // go through each segment to recursively break
+    for (let i = 0; i < splits.segments.length; i++) {
+        splits.segments[i] = breakUp(splits.segments[i], divisions, index + 1);
+    }
+
+    createEnvironments(splits, "_" + divisions[index]);
+
+    index++; // go to next division
+
+    // rebuild this part of the ast
+    return unsplitOnMacro(splits);
+}
+
+function createEnvironments(
+    splits: { segments: Ast.Node[][]; macros: Ast.Macro[] },
+    newEnviron: string
+): void {
+    // loop through segments (skipping first segment)
+    for (let i = 1; i < splits.segments.length; i++) {
+        // create the title
+        const title = getNamedArgsContent(splits.macros[i - 1])["title"];
+
+        // add title to the front of the segment
+        if (title) {
+            splits.segments[i].unshift(
+                m("title", (title[0] as Ast.Macro).content)
+            );
+        }
+
+        // wrap segment around a new environment
+        splits.segments[i] = [env(newEnviron, splits.segments[i])];
+    }
+}

packages/unified-latex-to-pretext/libs/pre-conversion-subs/expand-user-defined-macros.ts

@@ -0,0 +1,49 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+import {
+    expandMacrosExcludingDefinitions,
+    listNewcommands,
+} from "@unified-latex/unified-latex-util-macros";
+import { attachMacroArgs } from "@unified-latex/unified-latex-util-arguments";
+import { anyMacro } from "@unified-latex/unified-latex-util-match";
+import { EXIT, visit } from "@unified-latex/unified-latex-util-visit";
+
+type NewCommandSpec = ReturnType<typeof listNewcommands>[number];
+
+/**
+ * Expands user-defined macros
+ */
+export function expandUserDefinedMacros(ast: Ast.Ast): void {
+    const newcommands = listNewcommands(ast);
+
+    // get a set of all macros to be expanded
+    const macrosToExpand = new Set(newcommands.map((command) => command.name));
+
+    const macroInfo = Object.fromEntries(
+        newcommands.map((m) => [m.name, { signature: m.signature }])
+    );
+
+    // recursively expand at most 100 times
+    for (let i = 0; i < 100; i++) {
+        // check if any macros still need expanding
+        if (!needToExpand(ast, macrosToExpand)) {
+            break;
+        }
+
+        // attach the arguments to each macro before processing it
+        attachMacroArgs(ast, macroInfo);
+        expandMacrosExcludingDefinitions(ast, newcommands);
+    }
+}
+
+function needToExpand(ast: Ast.Ast, macros: Set<string>): boolean {
+    let needExpand = false;
+
+    visit(ast, (node) => {
+        if (anyMacro(node) && macros.has(node.content)) {
+            needExpand = true;
+            EXIT;
+        }
+    });
+
+    return needExpand;
+}

packages/unified-latex-to-pretext/libs/pre-conversion-subs/report-unsupported-macro-katex.ts

@@ -0,0 +1,27 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+import { anyMacro, match } from "@unified-latex/unified-latex-util-match";
+import { visit } from "@unified-latex/unified-latex-util-visit";
+import { KATEX_SUPPORT } from "./katex-subs";
+
+/**
+ * Return list of macros unsupported by Katex
+ */
+export function reportMacrosUnsupportedByKatex(ast: Ast.Ast): string[] {
+    const unsupported: string[] = [];
+
+    // match a macro supported by Katex
+    const isSupported = match.createMacroMatcher(KATEX_SUPPORT.macros);
+
+    // visit all nodes
+    visit(ast, (node, info) => {
+        // macro in math mode
+        if (anyMacro(node) && info.context.hasMathModeAncestor) {
+            // check if not supported by katex
+            if (!isSupported(node)) {
+                unsupported.push((node as Ast.Macro).content);
+            }
+        }
+    });
+
+    return unsupported;
+}

packages/unified-latex-to-pretext/tests/break-on-boundaries.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from "vitest";
+import util from "util";
+import { getParser } from "@unified-latex/unified-latex-util-parse";
+import { printRaw } from "@unified-latex/unified-latex-util-print-raw";
+import { breakOnBoundaries } from "../libs/break-on-boundaries";
+
+// Make console.log pretty-print by default
+const origLog = console.log;
+console.log = (...args) => {
+    origLog(...args.map((x) => util.inspect(x, false, 10, true)));
+};
+
+describe("unified-latex-to-pretext:break-on-boundaries", () => {
+    let value: string;
+
+    it("can break on parts", () => {
+        value = String.raw`\part{Foo}Hi, this is a part\part{Bar}This is another part`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        breakOnBoundaries(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\begin{_part}\title{Foo}Hi, this is a part\end{_part}\begin{_part}\title{Bar}This is another part\end{_part}`
+        );
+    });
+
+    it("can break on a combination of divisions", () => {
+        value = String.raw`\part{part1}\section{Section1}Hi, this is a section\chapter{chap1}This is a chapter\section{Subsection2}`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        breakOnBoundaries(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\begin{_part}\title{part1}` +
+                String.raw`\begin{_section}\title{Section1}Hi, this is a section\end{_section}` +
+                String.raw`\begin{_chapter}\title{chap1}This is a chapter` +
+                String.raw`\begin{_section}\title{Subsection2}\end{_section}\end{_chapter}\end{_part}`
+        );
+    });
+
+    it("can break on divisions wrapped around by a document environment", () => {
+        value = String.raw`\begin{document}\section{name}Hi, this is a subsection\subsubsection{title}description.\end{document}`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        breakOnBoundaries(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\begin{document}\begin{_section}\title{name}Hi, this is a subsection` +
+                String.raw`\begin{_subsubsection}\title{title}description.\end{_subsubsection}` +
+                String.raw`\end{_section}\end{document}`
+        );
+    });
+
+    it("can break on divisions wrapped around by different environments", () => {
+        value =
+            String.raw`\begin{center}\part{name}Hi, this is a part\begin{environ}` +
+            String.raw`\subparagraph{title}description.\end{environ}\end{center}`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        breakOnBoundaries(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\begin{center}\begin{_part}\title{name}Hi, this is a part` +
+                String.raw`\begin{environ}\begin{_subparagraph}\title{title}description.` +
+                String.raw`\end{_subparagraph}\end{environ}\end{_part}\end{center}`
+        );
+    });
+
+    it("can break on divisions in a group", () => {
+        value =
+            String.raw`\begin{document}\chapter{Chap}` +
+            String.raw`{\paragraph{Intro}Introduction.\begin{center}\subparagraph{Conclusion}Conclusion.\end{center}}` +
+            String.raw`Chapter finished.\end{document}`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        breakOnBoundaries(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\begin{document}\begin{_chapter}\title{Chap}{\begin{_paragraph}\title{Intro}Introduction.` +
+                String.raw`\begin{center}\begin{_subparagraph}\title{Conclusion}Conclusion.\end{_subparagraph}` +
+                String.raw`\end{center}\end{_paragraph}}Chapter finished.\end{_chapter}\end{document}`
+        );
+    });
+});

packages/unified-latex-to-pretext/tests/expand-user-defined-macros.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import util from "util";
+import { getParser } from "@unified-latex/unified-latex-util-parse";
+import { printRaw } from "@unified-latex/unified-latex-util-print-raw";
+import { expandUserDefinedMacros } from "@unified-latex/unified-latex-to-pretext/libs/pre-conversion-subs/expand-user-defined-macros";
+
+// Make console.log pretty-print by default
+const origLog = console.log;
+console.log = (...args) => {
+    origLog(...args.map((x) => util.inspect(x, false, 10, true)));
+};
+
+describe("unified-latex-to-pretext:expand-user-deifned-macros", () => {
+    let value: string;
+
+    it("can expand newcommand", () => {
+        value = String.raw`\newcommand{\foo}{\bar} \foo`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        expandUserDefinedMacros(ast);
+
+        expect(printRaw(ast)).toEqual(String.raw`\newcommand{\foo}{\bar} \bar`);
+    });
+
+    it("can expand renewcommand", () => {
+        value = String.raw`\renewcommand{\O}{\mathcal{O}} \O`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        expandUserDefinedMacros(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\renewcommand{\O}{\mathcal{O}} \mathcal{O}`
+        );
+    });
+
+    it("can recursively expand multiple user-defined commands", () => {
+        value =
+            String.raw`\newcommand{\join}{\vee}` +
+            String.raw`\join` +
+            String.raw`\renewcommand{\vee}{\foo}` +
+            String.raw`\vee` +
+            String.raw`\renewcommand{\foo}{\bar}` +
+            String.raw`\foo`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        expandUserDefinedMacros(ast);
+
+        expect(printRaw(ast)).toEqual(
+            String.raw`\newcommand{\join}{\vee}` +
+                String.raw`\bar` +
+                String.raw`\renewcommand{\vee}{\foo}` +
+                String.raw`\bar` +
+                String.raw`\renewcommand{\foo}{\bar}` +
+                String.raw`\bar`
+        );
+    });
+
+    it("can expand providecommand", () => {
+        value = String.raw`\providecommand{\bar}{\b} \bar`;
+
+        const parser = getParser();
+        const ast = parser.parse(value);
+
+        expandUserDefinedMacros(ast);
+
+        expect(printRaw(ast)).toEqual(String.raw`\providecommand{\bar}{\b} \b`);
+    });
+});