feat: replace some mathjax with mermaid

Author: MC-XiaoHei

docs/.vitepress/config.mts

@@ -9,6 +9,7 @@ import fs from "fs";
 import {exampleAutoAnchorPreprocessor} from "./theme/anchor/exampleAutoAnchorPreprocessor";
 import {mathjaxContainerPreprocessor} from "./theme/mathjax/mathjaxContainerPreprocessor";
 import {withMermaid} from "vitepress-plugin-mermaid";
+import {mermaidSpaceConverter} from "./theme/mermaid/mermaidSpaceConverter";
 
 const defaultLocale: string = 'en';
 const supportLocales: string[] = [
@@ -106,6 +107,7 @@ const vitepressOptions: UserConfig = {
         },
         config: (md) => {
             tabsPlugin(md);
+            mermaidSpaceConverter(md);
             exampleAutoAnchorPreprocessor(md);
             mathjaxContainerPreprocessor(md);
         }

docs/.vitepress/theme/mermaid/mermaidSpaceConverter.ts

@@ -0,0 +1,19 @@
+import MarkdownIt from "markdown-it";
+import slugify from "@sindresorhus/slugify";
+
+export const mermaidSpaceConverter = (md: MarkdownIt) => {
+    md.core.ruler.before('normalize', 'mermaid-space-converter', (state) => {
+        if(!state.src.includes("```mermaid")) {
+            return;
+        }
+        const blocks = state.src.split("```mermaid");
+        state.src = blocks.map((block) => {
+            const split = block.split("```");
+            split[0] = split[0].replace(/(\[.*?]|\{.*?}|\(.*?\))/g, (match) => {
+                return match.replace(/ /g, ' ');
+            });
+            return split.join("```");
+        }).join("```mermaid");
+    });
+}
+

docs/en/create-commands/arguments/types/list-arguments.md

@@ -19,15 +19,13 @@ List arguments allows users to provide a list of values. This argument can take
 
 Unlike other arguments, because this argument can be interpreted in various different ways, this argument can only be created using a `ListArgumentBuilder`, instead of directly accessing the `ListArgument` constructor. The `ListArgumentBuilder` loosely follows the following format:
 
-$$
-\begin{align}
-&\quad\texttt{Create a ListArgumentBuilder} \\\\
-\rightarrow&\quad\texttt{(Provide the list delimiter)} \\\\
-\rightarrow&\quad\texttt{Provide the list to pull suggestions from} \\\\
-\rightarrow&\quad\texttt{Provide the mapper of the list items to a string} \\\\
-\rightarrow&\quad\texttt{Build the ListArgument}
-\end{align}
-$$
+```mermaid
+graph TD
+    A(Create a ListArgumentBuilder) --> B("(Provide the list delimiter)")
+    B --> C(Provide the list to pull suggestions from)
+    C --> D(Provide the mapper of the list items to a string)
+    D --> E(Build the ListArgument)
+```
 
 ### Construction
 

docs/en/create-commands/arguments/types/map-arguments.md

@@ -15,14 +15,14 @@ It returns a `LinkedHashMap` object.
 
 Similar to the `ListArgument`, this argument also uses a builder class to construct it.
 
-$$\begin{align}
-&\quad\texttt{Create a MapArgumentBuilder and possibly provide the delimiter or separator} \\\\
-\rightarrow&\quad\texttt{Provide the mapper from a string to an object of the provided key type} \\\\
-\rightarrow&\quad\texttt{Provide the mapper from a string to an object of the provided value type} \\\\
-\rightarrow&\quad\texttt{Provide the list with keys to pull suggestions from} \\\\
-\rightarrow&\quad\texttt{Provide the list with values to pull suggestions from} \\\\
-\rightarrow&\quad\texttt{Build the MapArgument}
-\end{align}$$
+```mermaid
+graph TD
+    A(Create a MapArgumentBuilder<br/>possibly provide the delimiter or separator) --> B(Provide the mapper from a string to an object of the provided key type)
+    B --> C(Provide the mapper from a string to an object of the provided value type)
+    C --> D(Provide the list with keys to pull suggestions from)
+    D --> E(Provide the list with values to pull suggestions from)
+    E --> F(Build the MapArgument)
+```
 
 ### Building a `MapArgument`
 

docs/en/create-commands/arguments/types/misc/angle-arguments.md

@@ -9,15 +9,18 @@ authors:
 The angle argument is used to represent the _yaw_ (horizontal) angle in degrees. The value returned from this argument range from -180.0 (inclusive) to 180 (exclusive), with -180.0 being due north:
 
 $$
-\begin{align}
--1&80.0 \\\\
-&\hspace{0.1em}N \\\\
-&\uparrow \\\\
-90.0\ W \leftarrow &\hspace{0.75em}\rightarrow E\ -90.0 \\\\
-&\downarrow \\\\
-&\hspace{0.2em}S \\\\
-&0.0 \\\\
-\end{align}
+\begin{array}{c}
+& N (-180°) & \\
+& \uparrow & \\
+& & \\
+& & \\
+W (90°) \leftarrow\hspace{0.4em} & \bullet & \hspace{0.4em}\rightarrow E (-90°) \\
+& & \\
+& & \\
+& \downarrow & \\
+& S (0°) & \\
+\end{array}
 $$
 
+
 The `~` notation can be used to specify a rotation relative to the executor's yaw angle.

docs/en/create-commands/executors/normal-executors.md

@@ -104,17 +104,15 @@ This saves having to use `instanceof` multiple times to check the type of the `C
 
 The different command sender priority is the following (from the highest priority to the lowest priority):
 
-$$
-\begin{align}
-&\quad\texttt{.executesNative()} && \texttt{(Always chosen if used)}\\\\
-&\quad\texttt{.executesPlayer()} \\\\
-&\quad\texttt{.executesEntity()} \\\\
-&\quad\texttt{.executesConsole()} \\\\
-&\quad\texttt{.executesCommandBlock()} \\\\
-&\quad\texttt{.executesProxy()} \\\\
-&\quad\texttt{.executes()}
-\end{align}
-$$
+```mermaid
+graph TD
+    A(".executesNative() (Always chosen if used)") --> B(".executesPlayer()")
+    B --> C(".executesEntity()")
+    C --> D(".executesConsole()")
+    D --> E(".executesCommandBlock()")
+    E --> F(".executesProxy()")
+    F --> G(".executes()")
+```
 
 ## Multiple command executors with the same implementation
 

docs/en/faq.md

@@ -42,21 +42,11 @@ No. That message is handled client-side and isn't controlled by the CommandAPI.
 
 ```java
 new CommandAPICommand("mycommand")
-    .withPermission("some.permission")
+    .withPermission("some.permission") // [!code --]
     .executes((sender, args) -> {
-        sender.sendMessage("Hello!");
-    })
-    .register();
-```
-
-$$\downarrow$$
-
-```java
-new CommandAPICommand("mycommand")
-    .executes((sender, args) -> {
-        if(!sender.hasPermission("some.permission")) {
-            throw CommandAPI.failWithString("You don't have permission to run /mycommand!");
-        }
+        if(!sender.hasPermission("some.permission")) { // [!code ++]
+            throw CommandAPI.failWithString("You don't have permission to run /mycommand!"); // [!code ++]
+        } // [!code ++]
         sender.sendMessage("Hello!");
     })
     .register();
@@ -73,11 +63,7 @@ Arguments with suggestions provided using `ArgumentSuggestions.strings(String...
 The easiest way to do this is to add `info ->` at the start of your array:
 
 ```java
-ArgumentSuggestions.strings(SomeClass.someArray);
-```
-
-$$\downarrow$$
+ArgumentSuggestions.strings(SomeClass.someArray); // [!code --]
 
-```java
-ArgumentSuggestions.strings(info -> SomeClass.someArray);
+ArgumentSuggestions.strings(info -> SomeClass.someArray); // [!code ++]
 ```

docs/en/incompatible-versions.md

@@ -25,24 +25,34 @@ Running functions generated via the `FunctionArgument` on Minecraft version **1.
 
 In Minecraft version **1.16**, the way datapacks were loaded changed in such a way that the CommandAPI had to put in additional countermeasures to provide full support to it. To illustrate this, this was the previous loading sequence for Bukkit servers in Minecraft 1.15:
 
-$\texttt{Server loads}\rightarrow\texttt{Plugins load}\rightarrow\texttt{Datapacks load}\rightarrow\texttt{Server finishes loading}$
-
-Instead however, Minecraft 1.16 changed the loading sequence to the following:
-
-$\texttt{Server loads}\rightarrow\texttt{Datapacks load}\rightarrow\texttt{Plugins load}\rightarrow\texttt{Server finishes loading}$
+```mermaid
+graph LR
+    A(Start loads) --> B(Plugins load)
+    B --> C(DataPacks load)
+    C --> D(Server finishes loading)
+```
+
+However, Minecraft 1.16 changed the loading sequence to the following:
+
+```mermaid
+graph LR
+    A(Start loads) --> B(DataPacks load)
+    B --> C(Plugins load)
+    C --> D(Server finishes loading)
+```
 
 Because the CommandAPI used to register vanilla Minecraft commands _before_ datapacks (and thus, custom Minecraft functions), it was possible to register custom commands that can be used in functions. With this new loading sequence change in Minecraft 1.16, this meant that datapacks load first before the CommandAPI does, so custom commands are not registered and functions with custom commands would fail to load.
 
 To resolve this, the CommandAPI reloads datapacks _and recipes_ at the end:
 
-$$\begin{align}
-&\quad\texttt{Server loads} \\\\
-\rightarrow&\quad\texttt{Datapacks load} \\\\
-\rightarrow&\quad\texttt{Plugins load} \\\\
-\rightarrow&\quad\texttt{Server finishes loading} \\\\
-\rightarrow&\quad\texttt{Datapacks are reloaded} && \texttt{(by the CommandAPI)} \\\\
-\rightarrow&\quad\texttt{Recipes are reloaded} && \texttt{(by the CommandAPI)}
-\end{align}$$
+```mermaid
+graph TD
+    A(Server loads) --> B(DataPacks load)
+    B --> C(Plugins load)
+    C --> D(Server finishes loading)
+    D --> E("DataPacks are reloaded (by the CommandAPI)")
+    E --> F("Recipes are reloaded (by the CommandAPI)")
+```
 
 By doing this, this means:
 

docs/en/internal/brigadier-plus-commandapi.md

@@ -74,15 +74,15 @@ In this scenario, if we ran this command, we would expect "Hello!" to appear in
 ```mermaid
 graph TD
     A(execute) --> B(if)
-    B --> C("randomchance <numerator> <denominator>")
+    B --> C("randomchance <numerator> <denominator>")
 ```
 
 - After entering our predicate, we want to route back to `execute` (because the argument after `execute` is `run`, which is used in our example command above):
 
 ```mermaid
 graph TD
     A(execute) --> B(if)
-    B --> C("randomchance <numerator> <denominator>")
+    B --> C("randomchance <numerator> <denominator>")
     C --> D(execute)
 ```
 

docs/en/troubleshooting.md

@@ -20,16 +20,8 @@ This is most likely caused by using a constant array instead of using a lambda t
 ```java
 new StringArgument("players")
     .replaceSuggestions(ArgumentSuggestions.strings( 
-        Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)
-    ));
-```
-
-$$\downarrow$$
-
-```java
-new StringArgument("players")
-    .replaceSuggestions(ArgumentSuggestions.strings( 
-        info -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)
+        Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)  // [!code --]
+        info -> Bukkit.getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new)  // [!code ++]
     ));
 ```