misc bugfixes and styling

Author: dmca-glasgow

packages/processor/src/__test__/lists.test.ts

@@ -131,3 +131,39 @@ test('description to dl', async () => {
 
   expect(html).toBe(expectedHtml);
 });
+
+test.skip('description with newlines to dl', async () => {
+  const markdown = await testProcessor.latex(String.raw`
+    \begin{description}
+    \item[Nabla identities] $a$,\\
+      $b$,\\
+      $c$.
+    \end{description}
+  `);
+  // console.log(markdown);
+  // return;
+
+  const expectedMarkdown = unindentStringAndTrim(String.raw`
+    Nabla identities
+    :   $a$,\
+        $b$,\
+        $c$.
+  `);
+
+  expect(markdown).toBe(expectedMarkdown);
+
+  const html = await testProcessor.md(markdown);
+  // console.log(html);
+
+  const expectedHtml = unindentStringAndTrim(`
+    <dl>
+      <dt>Nabla identities</dt>
+      <dd><code class="latex">a</code>,<br />
+        <code class="latex">b</code>,<br />
+        <code class="latex">c</code>.
+      </dd>
+    </dl>
+  `);
+
+  expect(html).toBe(expectedHtml);
+});

packages/processor/src/markdown-to-mdx/hast-transforms/index.ts

@@ -47,23 +47,6 @@ export function createRehypePlugins(
   return plugins;
 }
 
-// export async function toHast(
-//   children: PhrasingContent[],
-//   ctx: Context,
-//   options: Partial<Options> = {},
-// ) {
-//   const processor = unified().use(
-//     createRehypeFragmentPlugins(ctx, options),
-//   );
-
-//   const root: Root = {
-//     type: 'root',
-//     children,
-//   };
-//   const hast = (await processor.run(root)) as Root;
-//   return hast.children as ElementContent[];
-// }
-
 function createRehypeFragmentPlugins(
   ctx: Context,
   _options: Partial<Options> = {},
@@ -72,7 +55,6 @@ function createRehypeFragmentPlugins(
     addDefaultAltText,
     missingMathsImageToSvg,
     addMathsRefsAndCount,
-    removeEmptyParagraphs,
 
     [replaceFootnoteRefDefs, ctx],
     [footNotesToSideNotes, ctx],
@@ -84,6 +66,7 @@ function createRehypeFragmentPlugins(
     //   properties: { className: 'link' },
     // },
     // ],
+    removeEmptyParagraphs,
 
     // should be last
     [mathTagToRefLabel, ctx],

packages/processor/src/plugins/div-syntax/mdx-divs.ts

@@ -25,6 +25,8 @@ export function divSyntax(_ctx: Context) {
     visit(tree, 'containerDirective', (node) => {
       if (node.name === ' ') {
         const id = node.attributes?.id;
+        const className = node.attributes?.class;
+
         if (id) {
           const [abbr] = id.split('-');
           const float = defaultFloats.find((o) => o.abbr === abbr);
@@ -34,11 +36,8 @@ export function divSyntax(_ctx: Context) {
               createFigure(node, float.name, ctxObj, id);
             }
           }
-        }
-
-        const klass = node.attributes?.class;
-        if (klass) {
-          const classes = klass.split(' ');
+        } else if (className) {
+          const classes = className.split(' ');
           if (classes.includes('fig')) {
             const float = defaultFloats.find((o) => o.abbr === 'fig');
             if (float) {
@@ -75,7 +74,7 @@ function createFigure(
 
   const contentHast = getContentHast(content);
 
-  children.push(...contentHast);
+  children.push(contentHast);
 
   // if (caption.length > 0) {
   const strong: Element = {
@@ -191,7 +190,16 @@ function getContentHast(content: (BlockContent | DefinitionContent)[]) {
     children: content,
   }) as Element;
 
-  return contentHast.children;
+  const elem: ElementContent = {
+    type: 'element',
+    tagName: 'div',
+    properties: {
+      className: ['fig-content'],
+    },
+    children: contentHast.children,
+  };
+
+  return elem;
 }
 
 function removeDupes(arr: string[]) {

packages/processor/src/plugins/images/__test__/images.test.ts

@@ -638,3 +638,50 @@ test('images with no label or caption', async () => {
 
   expect(html).toBe(expectedHtml);
 });
+
+test('images with includegraphics*', async () => {
+  const latex = String.raw`
+    \documentclass{article}
+    \usepackage{graphicx}
+    \begin{document}
+
+    \begin{figure}
+      \includegraphics*[alt={Alpha}]{fig/ex1-2a.png}
+      \includegraphics*[alt={Bravo}]{fig/ex1-2b.png}
+      \includegraphics*[alt={Charlie}]{fig/ex1-2c.png}
+    \end{figure}
+
+    \end{document}
+  `;
+
+  const markdown = await testProcessor.latex(latex);
+  // console.log(markdown);
+
+  const expectedMarkdown = unindentStringAndTrim(`
+    ::: {.fig}
+
+    ![](fig/ex1-2a.png){alt="Alpha"}
+
+    ![](fig/ex1-2b.png){alt="Bravo"}
+
+    ![](fig/ex1-2c.png){alt="Charlie"}
+
+    :::
+  `);
+
+  expect(markdown).toBe(expectedMarkdown);
+
+  const html = await testProcessor.md(markdown);
+  // console.log(html);
+
+  const expectedHtml = unindentStringAndTrim(String.raw`
+    <figure>
+      <p><img src="fig/ex1-2a.png" alt="Alpha" /></p>
+      <p><img src="fig/ex1-2b.png" alt="Bravo" /></p>
+      <p><img src="fig/ex1-2c.png" alt="Charlie" /></p>
+      <figcaption><strong>Figure 1</strong></figcaption>
+    </figure>
+  `);
+
+  expect(html).toBe(expectedHtml);
+});

packages/processor/src/plugins/images/create-image.ts

@@ -23,13 +23,19 @@ export function createImage(node: Macro): Macro {
   const attrs = args.slice(0, -1).filter(Boolean).flat() as Ast.Node[];
   // console.dir(attrs, { depth: null });
 
+  const altIdx = attrs.findIndex((o) => {
+    return o.type === 'string' && o.content === 'alt';
+  });
   if (
-    attrs[0] &&
-    attrs[0].type === 'string' &&
-    attrs[0].content === 'alt' &&
-    attrs[2].type === 'group'
+    altIdx !== -1 &&
+    attrs.length > 2 &&
+    attrs[altIdx + 1].type === 'string' &&
+    // @ts-expect-error
+    attrs[altIdx + 1].content === '=' &&
+    attrs[altIdx + 2].type === 'group'
   ) {
-    attributes.alt = convertToMarkdown(attrs[2].content).trim();
+    // @ts-expect-error
+    attributes.alt = convertToMarkdown(attrs[altIdx + 2].content).trim();
   }
 
   // const id = attrs.find(

packages/processor/src/plugins/images/pandoc-implicit-figures.ts

@@ -96,14 +96,30 @@ export function pandocImplicitFigures() {
         );
       }
 
+      const figContent: Element = {
+        type: 'element',
+        tagName: 'div',
+        properties: {
+          className: ['fig-content'],
+        },
+        children: [
+          {
+            type: 'element',
+            tagName: 'p',
+            properties: {},
+            children: [img],
+          },
+        ],
+      };
+
       parent.data = {
         hName: 'figure',
         hProperties: {
           src: null,
           alt: null,
           id,
         },
-        hChildren: [img, figCaption],
+        hChildren: [figContent, figCaption],
       };
     });
     // console.dir(tree, { depth: null });

packages/processor/src/plugins/maths/__test__/maths.test.ts

@@ -359,6 +359,50 @@ test('expand newcommand inside newcommand', async () => {
   // console.log(quartoHtml);
 });
 
+test('maths equation with tag', async () => {
+  const latex = String.raw`
+    \documentclass{article}
+    \usepackage{amsmath}
+    \begin{document}
+    \begin{equation}
+      a+b\tag{$*$}
+    \end{equation}
+    \end{document}
+  `;
+
+  const markdown = await testProcessor.latex(latex);
+  // console.log(markdown);
+  // return;
+
+  const expectedMarkdown = unindentStringAndTrim(String.raw`
+    $$
+    \begin{equation}a+b\tag{$*$}\end{equation}
+    $$
+  `);
+
+  expect(markdown).toBe(expectedMarkdown);
+
+  const html = await testProcessor.md(markdown, {
+    // state: {
+    //   maths: {
+    //     mathsAsTex: false,
+    //     mathsFontName: 'computerModern',
+    //     syntaxHighlight: false,
+    //   },
+    // },
+  });
+  // console.log(html);
+
+  const expectedHtml = unindentStringAndTrim(String.raw`
+    <p class="maths env-equation"><code class="latex">\begin{equation}a+b\end{equation}</code><span class="eq-tag">(<code class="latex">*</code>)</span></p>
+  `);
+
+  expect(html).toBe(expectedHtml);
+
+  // const quartoHtml = await markdownToQuartoHtml(markdown);
+  // console.log(quartoHtml);
+});
+
 test('maths equations with labels and tags', async () => {
   const latex = String.raw`
     \documentclass{article}

packages/processor/src/plugins/maths/math-tag-to-ref-label.ts

@@ -1,11 +1,13 @@
-import { Root } from 'hast';
+import { ElementContent, Parent, Root } from 'hast';
+import remarkRehype from 'remark-rehype';
 import { visit } from 'unist-util-visit';
 
+import { createRemarkProcessor } from '../../remark-processor';
+
 const pattern = /\\tag\{(.+?)\}/;
 
 export function mathTagToRefLabel() {
   return (tree: Root) => {
-    // console.dir(tree, { depth: null });
     visit(tree, 'element', (node) => {
       if (node.tagName === 'pre') {
         if (node.children.length > 1) {
@@ -28,13 +30,18 @@ export function mathTagToRefLabel() {
                 if (match !== null) {
                   // remove tag
                   codeFirst.value = codeFirst.value.replace(pattern, '');
+
                   // add tag as eq-count attribute
+                  const tag = match[1];
                   const eqCountFirst = eqCount.children[0];
-                  if (
-                    eqCountFirst.type === 'element' &&
-                    eqCountFirst.properties['data-id']
-                  ) {
-                    eqCountFirst.properties['data-tag'] = match[1];
+                  if (eqCountFirst.type === 'element') {
+                    const id = eqCountFirst.properties['data-id'];
+                    if (id) {
+                      eqCountFirst.properties['data-tag'] = tag;
+                    } else {
+                      eqCount.properties.className = ['eq-tag'];
+                      eqCount.children = getTagHast(`(${tag})`);
+                    }
                   }
                 }
               }
@@ -45,3 +52,16 @@ export function mathTagToRefLabel() {
     });
   };
 }
+
+const processor = createRemarkProcessor([remarkRehype]);
+
+function getTagHast(tag: string) {
+  const parsed = processor.parse(String(tag));
+  const transformed = processor.runSync(parsed) as Parent;
+
+  if (transformed.children.length === 0) {
+    return [];
+  }
+  const firstChild = transformed.children[0] as Parent;
+  return firstChild.children as ElementContent[];
+}