📑 Use glossarium to support glossaries in typst

.changeset/tasty-tips-wonder.md

@@ -0,0 +1,5 @@
+---
+"myst-to-typst": patch
+---
+
+Fix glossary rendering

packages/myst-to-typst/src/index.ts

@@ -65,6 +65,14 @@ const blockquote = `#let blockquote(node, color: gray) = {
 
 const INDENT = '  ';
 
+function identifierToTerm(identifier: string): string {
+  // Try and strip off the term- prefix, as we're using #gls() for now
+  // which makes it obvious that we have a term
+  const match = identifier.match(/term-(.*)/);
+  // Fall back to full identifier (in case this changes in future)
+  return match?.[1] ?? identifier;
+}
+
 const linkHandler = (node: any, state: ITypstSerializer) => {
   const href = node.url;
   state.write('#link("');
@@ -249,6 +257,42 @@ const handlers: Record<string, Handler> = {
     });
     state.renderChildren(node);
   },
+  glossary(node, state) {
+    state.useMacro(`
+#import "@preview/glossarium:0.4.1": make-glossary, print-glossary, gls, glspl 
+#show: make-glossary
+`);
+    state.write(`#print-glossary(
+    disable-back-references: true,
+    (
+`);
+
+    const definitionList = node.children[0];
+    for (let i = 0; i < definitionList.children.length - 1; i += 2) {
+      const termNode = definitionList.children[i];
+      const definitionNode = definitionList.children[i + 1];
+
+      state.write(`        (`);
+
+      const term = identifierToTerm(termNode.identifier);
+      state.write(`key: "${term}"`);
+
+      state.write(`, short: [`);
+      state.renderChildren(termNode);
+      state.write(`]`);
+
+      state.write(`, desc: [`);
+      state.renderChildren(definitionNode);
+      state.write(`]`);
+
+      state.write(`),\n`);
+    }
+    state.write(
+      `    )
+)
+`,
+    );
+  },
   link: linkHandler,
   admonition(node: Admonition, state) {
     state.useMacro(admonition);
@@ -295,6 +339,11 @@ const handlers: Record<string, Handler> = {
   legend: captionHandler,
   captionNumber: () => undefined,
   crossReference(node, state, parent) {
+    if (node.kind === 'definitionTerm') {
+      const term = identifierToTerm(node.identifier);
+      state.write(`#gls("${term}")`);
+      return;
+    }
     // Look up reference and add the text
     // const usedTemplate = node.template?.includes('%s') ? node.template : undefined;
     // const text = (usedTemplate ?? toText(node))?.replace(/\s/g, '~') || '%s';

packages/myst-to-typst/tests/glossary.yml

@@ -0,0 +1,50 @@
+title: myst-to-typst glossary
+cases:
+  - title: reference single term
+    mdast:
+      type: root
+      children:
+        - type: glossary
+          children:
+            - type: definitionList
+              children:
+                - type: definitionTerm
+                  children:
+                    - type: text
+                      value: foo
+                  label: foo
+                  identifier: term-foo
+                - type: definitionDescription
+                  children:
+                    - type: text
+                      value: A foo
+                - type: definitionTerm
+                  children:
+                    - type: text
+                      value: bar
+                  label: bar
+                  identifier: term-bar
+                - type: definitionDescription
+                  children:
+                    - type: text
+                      value: A bar
+        - type: paragraph
+          children:
+            - type: crossReference
+              label: foo
+              identifier: term-foo
+              kind: definitionTerm
+              children:
+                - type: text
+                  value: foo
+              template: '{name}'
+              resolved: true
+    typst: |-
+      #print-glossary(
+          disable-back-references: true,
+          (
+              (key: "foo", short: [foo], desc: [A foo]),
+              (key: "bar", short: [bar], desc: [A bar]),
+          )
+      )
+      #gls("foo")