Adding macros

Author: bryan-ente

README.md

@@ -32,6 +32,7 @@ ProtoML is a lightweight, declarative markup language designed for writing and s
 ## Example
 ```plaintext
 @tags_import "tags.pml"
+@macro myMacro "myMacro.pml"
 
 @date:21.05.2025
 @participants // or @ptp
@@ -52,6 +53,8 @@ ProtoML is a lightweight, declarative markup language designed for writing and s
 # Meeting Title: @@e=0 // echoes value of ID 0
 ## Participants
 @@e=pt1 , @@e=pt2
+## Some topic
+@@macro=myMacro:title=IMPORTANT;text=@@e=1
 .....
 
 ```
@@ -64,6 +67,16 @@ ProtoML is a lightweight, declarative markup language designed for writing and s
 =important:Critical, high priority
 ```
 
+## External macro file (myMacro.pml)
+
+```plaintext
+@new_macro
+=name:myMacro
+=template:
+<div class="warn-box><strong>{{title}}</strong><br />{{text}}</div>
+
+```
+
 ## Parser logic (simplified)
 
 - `@` starts a block

package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoml-parser",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "ProtoML is a lightweight, declarative markup language designed for writing and structuring meeting protocols, notes and task lists in a human-readable and machine-parseable format.",
   "keywords": [
     "protoml",

src/core/blockParser.js

@@ -9,7 +9,14 @@ function parseBlocks(tokens, options = {}) {
       continue;
     }
 
+    if (token.type === "macro") {
+      result.macros = result.macros || {};
+      result.macros[token.name.trim()] = token.file.trim();
+      continue;
+    }
+
     if (token.type === "command") {
+
       currentBlock = token.value.toLowerCase();
       if (!result[currentBlock]) {
         result[currentBlock] =
@@ -49,7 +56,7 @@ function parseBlocks(tokens, options = {}) {
           const tag = token.raw.match(/@tag=([^\s]+)/)?.[1] || null;
 
           const cleanedText = token.value
-            .replace(/^\[(x| )\]/, "") 
+            .replace(/^\[(x| )\]/, "")
             .replace(/@ptp=[^\s]+/g, "")
             .replace(/@tag=[^\s]+/g, "")
             .replace(/=[^\s]+/g, "")

src/core/loader.js

@@ -43,4 +43,46 @@ function findTagImports(ast) {
     .map(match => match[1])
 }
 
-module.exports = { loadAndMergeImports }
+const macroCache = {}
+
+function loadAndMergeMacros(ast, basePath, options = {}) {
+  if (!ast.macros) return ast
+
+  for (const name in ast.macros) {
+    const file = ast.macros[name]
+    const fullPath = path.join(basePath, file.replace(/\"/g, ""))
+
+    if (!fs.existsSync(fullPath)) continue
+    const lines = fs.readFileSync(fullPath, "utf8").split(/\r?\n/)
+
+    let macroName = null
+    let templateLines = []
+    let inTemplate = false
+
+    for (const line of lines) {
+      if (line.startsWith("=name:")) {
+        macroName = line.slice(6).trim()
+      } else if (line.startsWith("=template:")) {
+        inTemplate = true
+        const rest = line.slice(10).trim()
+        if (rest) templateLines.push(rest)
+      } else if (inTemplate && (line.startsWith("@") || line.startsWith("="))) {
+        // Stop reading template
+        inTemplate = false
+      } else if (inTemplate) {
+        templateLines.push(line)
+      }
+    }
+
+    if (macroName && templateLines.length) {
+      macroCache[macroName] = templateLines.join("\n")
+    }
+  }
+
+  ast._macroCache = macroCache
+  return ast
+}
+
+
+
+module.exports = { loadAndMergeImports, loadAndMergeMacros }

src/core/parser.js

@@ -5,7 +5,7 @@ const { tokenize } = require("./tokenizer")
 const { parseBlocks } = require("./blockParser")
 const { resolveReferences } = require("./referenceLinker")
 const { parseInline } = require("./inlineParser")
-const { loadAndMergeImports } = require("./loader")
+const { loadAndMergeImports, loadAndMergeMacros } = require("./loader")
 
 function parseFile(filename, options = {}) {
   if (!fs.existsSync(filename)) {
@@ -17,6 +17,7 @@ function parseFile(filename, options = {}) {
   let ast = parseBlocks(tokens, options)
 
   ast = loadAndMergeImports(ast, path.dirname(filename), options)
+  ast = loadAndMergeMacros(ast, path.dirname(filename), options)
 
   ast = resolveReferences(ast, options)
   ast = parseInline(ast, options)

src/core/referenceLinker.js

@@ -3,14 +3,45 @@ function resolveReferences(ast, options = {}) {
     if (!ast[group] || !ast[group][id]) {
       if (options.strict)
         throw new Error(`Unresolved reference @${group}=${id}`);
-      return {id, unresolved: true};
+      return { id, unresolved: true };
     }
-    return {id, ...ast[group][id]};
+    return { id, ...ast[group][id] };
+  };
+
+  const expandMacros = (block) => {
+    return block.flatMap((line) => {
+      const match = line.match(/@@macro=([\w-]+):(.*)/);
+      if (!match || !ast._macroCache) return [line];
+
+      const [_, macroName, rawParams] = match;
+      const template = ast._macroCache[macroName];
+      if (!template) return [line];
+
+      const params = {};
+      rawParams.split(";").forEach((p) => {
+        const [k, v] = p.split("=");
+        params[k.trim()] = v.trim();
+      });
+
+      const rendered = template.replace(/\{\{(.*?)\}\}/g, (_, key) => {
+        const val = params[key] || "";
+        if (val.startsWith("@@e=")) {
+          const id = val.slice(5);
+          return ast.subjects?.[id]
+            || ast.participants?.[id]?.name
+            || ast.tags?.[id]
+            || id;
+        }
+        return val;
+      });
+
+      return [rendered];
+    });
   };
 
   if (Array.isArray(ast.tasks)) {
     ast.tasks = ast.tasks.map((task) => {
-      const out = {...task};
+      const out = { ...task };
 
       const ptpMatch = task.raw.match(/@ptp=([^\s]+)/);
       const subjMatch = [...task.raw.matchAll(/(?:\s|^)=([^\s]+)/g)].pop();
@@ -25,32 +56,37 @@ function resolveReferences(ast, options = {}) {
   }
 
   if (Array.isArray(ast.meeting)) {
-    ast.meeting = ast.meeting.map((line) => {
-      const echoMatches = [...line.matchAll(/@@e=([^\s]+)/g)];
-      let resolved = line;
-
-      for (const match of echoMatches) {
-        const id = match[1];
-        let replacement = id;
-
-        if (ast.subjects?.[id]) {
-          replacement = ast.subjects[id];
-        } else if (ast.participants?.[id]) {
-          replacement = ast.participants[id].name;
-        } else if (ast.tags?.[id]) {
-          replacement = ast.tags[id];
-        } else if (options.strict) {
-          throw new Error(`@@e=${id} not found`);
+    ast.meeting = ast.meeting
+      .map((line) => {
+        const echoMatches = [...line.matchAll(/@@e=([^\s]+)/g)];
+        let resolved = line;
+
+        for (const match of echoMatches) {
+          const id = match[1];
+          let replacement = id;
+
+          if (ast.subjects?.[id]) {
+            replacement = ast.subjects[id];
+          } else if (ast.participants?.[id]) {
+            replacement = ast.participants[id].name;
+          } else if (ast.tags?.[id]) {
+            replacement = ast.tags[id];
+          } else if (options.strict) {
+            throw new Error(`@@e=${id} not found`);
+          }
+
+          resolved = resolved.replace(match[0], replacement);
         }
 
-        resolved = resolved.replace(match[0], replacement);
-      }
+        return resolved;
+      });
 
-      return resolved;
-    });
+    ast.meeting = expandMacros(ast.meeting);
   }
 
   return ast;
 }
 
+
+
 module.exports = {resolveReferences};

src/core/tokenizer.js

@@ -11,16 +11,22 @@ function tokenize(text) {
     }
     if (raw.match(/^@\w+:/)) {
       const [key, ...val] = raw.slice(1).split(":");
-      tokens.push({type: "meta", key, value: val.join(":").trim(), line});
+      tokens.push({ type: "meta", key, value: val.join(":").trim(), line });
+      continue;
+    }
+
+    if (raw.startsWith("@macro ")) {
+      const [, name, file] = raw.split(" ");
+      tokens.push({ type: "macro", name, file: file.replace(/\"/g, ""), raw, line });
       continue;
     }
 
     // Command block e.g. @participants
     if (raw.startsWith("@@")) {
-      tokens.push({type: "inlineCommand", raw, command: raw.slice(2), line});
+      tokens.push({ type: "inlineCommand", raw, command: raw.slice(2), line });
     } else if (raw.startsWith("@")) {
       const value = raw.slice(1).split(":")[0].split("=")[0];
-      tokens.push({type: "command", raw, value, line});
+      tokens.push({ type: "command", raw, value, line });
     }
     // Declaration with ID e.g. =pt1:Some value
     else if (raw.startsWith("=")) {
@@ -35,21 +41,20 @@ function tokenize(text) {
     }
     // List/entry item e.g. - Something
     else if (raw.startsWith("-")) {
-      tokens.push({type: "entry", raw, value: raw.slice(1).trim(), line});
+      tokens.push({ type: "entry", raw, value: raw.slice(1).trim(), line });
     }
     // Markdown header
     else if (raw.match(/^#{1,4}\s+/)) {
       const level = raw.match(/^#+/)[0].length;
       const value = raw.slice(level).trim();
-      tokens.push({type: "heading", raw, value, level, line});
+      tokens.push({ type: "heading", raw, value, level, line });
     }
     // Fallback
     else {
-      tokens.push({type: "text", raw, value: raw, line});
+      tokens.push({ type: "text", raw, value: raw, line });
     }
   }
-
   return tokens;
 }
 
-module.exports = {tokenize};
+module.exports = { tokenize };