Reapplied all the things

common/syscalls/markdown.ts

@@ -0,0 +1,16 @@
+import {SysCallMapping} from "../../plugos/system";
+import {MarkdownTree, nodeAtPos, parse, render} from "../tree";
+
+export function markdownSyscalls(): SysCallMapping {
+    return {
+        parse(ctx, text: string): MarkdownTree {
+            return parse(text);
+        },
+        nodeAtPos(ctx, mdTree: MarkdownTree, pos: number): MarkdownTree | null {
+            return nodeAtPos(mdTree, pos);
+        },
+        render(ctx, mdTree: MarkdownTree): string {
+            return render(mdTree);
+        },
+    };
+}

common/tree.test.ts

@@ -0,0 +1,26 @@
+import {expect, test} from "@jest/globals";
+import {nodeAtPos, parse, render} from "./tree";
+
+const mdTest1 = `
+# Heading
+## Sub _heading_ cool
+
+Hello, this is some **bold** text and *italic*. And [a link](http://zef.me).
+
+- This is a list
+- With another item
+- TODOs:
+  - [ ] A task that's not yet done
+  - [x] Hello
+- And a _third_ one [[Wiki Page]] yo
+`;
+
+test("Run a Node sandbox", async () => {
+  let mdTree = parse(mdTest1);
+  console.log(JSON.stringify(mdTree, null, 2));
+  expect(nodeAtPos(mdTree, 4)!.type).toBe("ATXHeading1");
+  expect(nodeAtPos(mdTree, mdTest1.indexOf("Wiki Page"))!.type).toBe(
+    "WikiLink"
+  );
+  expect(render(mdTree)).toBe(mdTest1);
+});

common/tree.ts

@@ -0,0 +1,115 @@
+import {SyntaxNode} from "@lezer/common";
+import wikiMarkdownLang from "../webapp/parser";
+
+export type MarkdownTree = {
+    type?: string; // undefined === text node
+    from: number;
+    to: number;
+    text?: string;
+    children?: MarkdownTree[];
+    parent?: MarkdownTree;
+};
+
+function treeToAST(text: string, n: SyntaxNode): MarkdownTree {
+    let children: MarkdownTree[] = [];
+    let nodeText: string | undefined;
+    let child = n.firstChild;
+    while (child) {
+        children.push(treeToAST(text, child));
+        child = child.nextSibling;
+    }
+
+    if (children.length === 0) {
+        children = [
+            {
+                from: n.from,
+                to: n.to,
+                text: text.substring(n.from, n.to),
+            },
+        ];
+    } else {
+        let newChildren: MarkdownTree[] | string = [];
+        let index = n.from;
+        for (let child of children) {
+            let s = text.substring(index, child.from);
+            if (s) {
+                newChildren.push({
+                    from: index,
+                    to: child.from,
+                    text: s,
+                });
+            }
+            newChildren.push(child);
+            index = child.to;
+        }
+        let s = text.substring(index, n.to);
+        if (s) {
+            newChildren.push({ from: index, to: n.to, text: s });
+        }
+        children = newChildren;
+    }
+
+    let result: MarkdownTree = {
+        type: n.name,
+        from: n.from,
+        to: n.to,
+    };
+    if (children.length > 0) {
+        result.children = children;
+    }
+    if (nodeText) {
+        result.text = nodeText;
+    }
+    return result;
+}
+
+// Currently unused
+function addParentPointers(mdTree: MarkdownTree) {
+    if (!mdTree.children) {
+        return;
+    }
+    for (let child of mdTree.children) {
+        child.parent = mdTree;
+        addParentPointers(child);
+    }
+}
+
+// Finds non-text node at position
+export function nodeAtPos(
+    mdTree: MarkdownTree,
+    pos: number
+): MarkdownTree | null {
+    if (pos < mdTree.from || pos > mdTree.to) {
+        return null;
+    }
+    if (!mdTree.children) {
+        return mdTree;
+    }
+    for (let child of mdTree.children) {
+        let n = nodeAtPos(child, pos);
+        if (n && n.text) {
+            // Got a text node, let's return its parent
+            return mdTree;
+        } else if (n) {
+            // Got it
+            return n;
+        }
+    }
+    return null;
+}
+
+// Turn MarkdownTree back into regular markdown text
+export function render(mdTree: MarkdownTree): string {
+    let pieces: string[] = [];
+    if (mdTree.text) {
+        return mdTree.text;
+    }
+    for (let child of mdTree.children!) {
+        pieces.push(render(child));
+    }
+    return pieces.join("");
+}
+
+export function parse(text: string): MarkdownTree {
+    return treeToAST(text, wikiMarkdownLang.parser.parse(text).topNode);
+}