markdown-maker 1.10.0 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "markdown-maker",
-    "version": "1.10.0",
+    "version": "1.10.1",
     "description": "",
     "main": "src/cltool.ts",
     "bin": {
@@ -52,6 +52,7 @@
         "colors": "^1.4.0",
         "colors.ts": "^1.0.20",
         "marked": "^2.0.1",
+        "node-html-parser": "^6.1.13",
         "require-runtime": "^2.0.0",
         "ws": "^8.8.1"
     },

package/src/commands.ts

@@ -3,6 +3,7 @@ import Parser from "./parse";
 import * as fs from "fs";
 import templates, { new_template } from "./templates";
 import requireRuntime from "require-runtime";
+import * as nodeHtmlParser from "node-html-parser";
 
 export class MDMError extends Error {
     match: RegExpMatchArray;
@@ -207,12 +208,65 @@ new Command(
     CommandType.PARSE
 );
 
+/* mdmaketoc */
 new Command(
     /#mdmaketoc(?:<>)?/,
     (match, parser) => parser.gen_toc(),
     CommandType.POSTPARSE
 );
 
+/* basic mdhook */
+new Command(
+    /#mdhook<(\w+)>/,
+    (match, parser) => {
+        if (parser.opts.hooks[match[1]]) {
+            return parser.opts.hooks[match[1]]();
+        }
+    },
+    CommandType.POSTPARSE
+);
+
+/* mdadvhook */
+new Command(
+    /\#mdadvhook<(\w+)>([\w\W]+?)\#mdendhook/,
+    (match, parser) => {
+        if (parser.opts.adv_hooks[match[1]]) {
+            const innerElements = match[2].trim();
+            /* Find tagNames in innerElements */
+            const re = /<(\w+)[\s=\w\"\'-]*>/g;
+            const tags = [];
+            innerElements.match(re)?.forEach((tag) => {
+                tags.push(tag.slice(1, -1).split(" ")[0]);
+            });
+            /* Evil type hack */
+            const root = nodeHtmlParser.parse(innerElements, {
+                voidTag: {
+                    tags,
+                    closingSlash: true,
+                },
+            }) as any as HTMLElement;
+
+            const helper = (node: HTMLElement) => {
+                /*  */
+                const map: { [tag: string]: HTMLElement } = {};
+                for (let tag of tags) {
+                    const el = node.getElementsByTagName(tag)[0];
+                    const dataTag = el.toString().match(/data-tag="([\w-]+)"/);
+                    if (!dataTag || dataTag[1] == undefined) continue;
+                    el.tagName = dataTag[1];
+                    el.removeAttribute("data-tag");
+                    map[tag] = el;
+                }
+                return map;
+            };
+
+            const hooked = parser.opts.adv_hooks[match[1]](root, helper(root));
+            return hooked.toString();
+        }
+    },
+    CommandType.POSTPARSE
+);
+
 const loaded_extentions: fs.PathLike[] = [];
 
 function load_extension(parser: Parser, file: fs.PathLike) {

package/src/parse.ts

@@ -1,9 +1,10 @@
-const fs = require("fs"); /* for handling reading of files */
-const path = require("path"); /* for handling file paths */
+import fs from "fs"; /* for handling reading of files */
+import path from "path"; /* for handling file paths */
 
 import Colors = require("colors.ts"); /* for adding colours to strings */
 Colors.enable();
-const marked = require("marked");
+import marked from "marked";
+
 import { Command, commands, load_extensions, MDMError } from "./commands";
 
 enum TargetType {
@@ -43,6 +44,13 @@ class Parser {
         targetType: TargetType | undefined;
         only_warn: boolean;
         parent?: Parser;
+        hooks: { [key: string]: () => string };
+        adv_hooks: {
+            [key: string]: (
+                tree: HTMLElement,
+                map: { [tag: string]: HTMLElement }
+            ) => HTMLElement;
+        };
         isFileCallback: (s: string) => false | string;
     };
     raw: string;
@@ -89,6 +97,8 @@ class Parser {
             targetType: undefined,
             only_warn: false,
             parent: undefined,
+            hooks: {},
+            adv_hooks: {},
             isFileCallback: (f) => {
                 if (!fs.existsSync(f)) return false;
                 return fs.readFileSync(f, "utf-8") + "\n";
@@ -237,13 +247,27 @@ class Parser {
             const link = this.titleId(title);
 
             let __line =
-                hor.repeat(Math.max(sec.level - 1, 0)) + beg + `[${title}](#${link})`;
+                hor.repeat(Math.max(sec.level - 1, 0)) +
+                beg +
+                `[${title}](#${link})`;
 
             __blob.push(__line);
         });
         return __blob.join("\n");
     }
 
+    add_hook(name: string, hook: () => string) {
+        if (this.opts.hooks[name] != undefined)
+            throw new Error(`Hook ${name} already exists!`);
+        this.opts.hooks[name] = hook;
+    }
+
+    add_adv_hook(name: string, hook: (tree: HTMLElement) => HTMLElement) {
+        if (this.opts.hooks[name] != undefined)
+            throw new Error(`Hook ${name} already exists!`);
+        this.opts.adv_hooks[name] = hook;
+    }
+
     line_num_from_index(index: number) {
         return this.raw.substring(0, index).split("\n").length + 1;
     }
@@ -258,7 +282,7 @@ class Parser {
     /* output the parsed document to bundle */
     to(bundleName: string, callback: (fileName: string) => void) {
         const dir = path.dirname(bundleName);
-        if (callback === undefined) callback = () => { };
+        if (callback === undefined) callback = () => {};
 
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
@@ -268,11 +292,11 @@ class Parser {
             this.get(TargetType.MARKDOWN, (blob) => {
                 fs.writeFile(bundleName, blob, () => callback(bundleName));
             });
-        }
-
-        else {
+        } else {
             const htmlFileName = bundleName.replace(".md", ".html");
-            fs.writeFile(htmlFileName, this.html(), () => callback(htmlFileName));
+            fs.writeFile(htmlFileName, this.html(), () =>
+                callback(htmlFileName)
+            );
         }
     }
 
@@ -301,7 +325,7 @@ class Parser {
                 let blob = this.parse();
                 this.opts.targetType = undefined;
                 if (callback) callback(blob);
-                return blob
+                return blob;
             } catch (error) {
                 /* Compile a traceback of error */
                 let traceback = "";
@@ -312,7 +336,9 @@ class Parser {
                         traceback += `\n...on line ${p.line_num_from_index(
                             error.match.index
                         )} in ${p.file}`.grey(15);
-                    else traceback += `\n...on line ${p.line_num} in ${p.file}`.grey(15);
+                    else
+                        traceback +=
+                            `\n...on line ${p.line_num} in ${p.file}`.grey(15);
                     if (p.parent) p = p.parent;
                 } while (p.parent);
 
@@ -353,7 +379,8 @@ marked.use({
             const id = args.filter((arg) => arg.startsWith("#"));
 
             const classNames = classes.map((c) => c.slice(1));
-            const classText = classes.length > 0 ? `class="${classNames.join(" ")}"` : "";
+            const classText =
+                classes.length > 0 ? `class="${classNames.join(" ")}"` : "";
             const idText = id.length > 0 ? `id="${id[0].slice(1)}"` : "";
 
             /* remove the ending from the quote */

package/test/basic.test.js

@@ -1,4 +1,3 @@
-const path = require("path");
 const util = require("./tester.test.js");
 
 describe("Basic features", () => {

package/test/errors.test.js

@@ -1,5 +1,4 @@
 const util = require("./tester.test.js");
-const fs = require("fs");
 
 describe("Error handling", () => {
     it("should dissallow undefined templates", () => {

package/test/hooks.js

@@ -2,7 +2,7 @@ const fs = require("fs");
 
 exports.mochaHooks = {
     beforeEach(done) {
-        fs.rmdirSync("test/test-files", { recursive: true });
+        fs.rmSync("test/test-files", { recursive: true });
         fs.mkdirSync("test/test-files");
         done();
     },

package/test/hooks.test.js

@@ -0,0 +1,114 @@
+const util = require("./tester.test.js");
+
+describe("Use of markdown hooks for SSR", () => {
+    it("should allow a simple hook to be used", () => {
+        util.put("#mdhook<test>", "sample1.md");
+
+        const parser = new util.Parser("test/test-files/sample1.md");
+        parser.add_hook("test", () => "hello");
+        const output = parser.get();
+
+        util.assert.strictEqual(output, "hello\n\n");
+    });
+    it("should allow advanced hooks to be used", () => {
+        util.put(
+            "#mdadvhook<test>\n<b>Bold</b>\n<p>Paragraph</p>\n#mdendhook",
+            "sample1.md"
+        );
+
+        const replacer = (arg) => {
+            const elem = new util.html.HTMLElement("p", {});
+            elem.set_content("complete");
+            return elem;
+        };
+
+        const parser = new util.Parser("test/test-files/sample1.md");
+        parser.opts.allow_undefined = true;
+        parser.add_adv_hook("test", replacer);
+        const output = parser.get();
+
+        util.assert.strictEqual(output, "<p>complete</p>\n\n");
+    });
+    it("should allow for hooks to be used in HTML", () => {
+        util.put("<html><body>#mdhook<test></body></html>", "sample1.html");
+
+        const parser = new util.Parser("test/test-files/sample1.html");
+        parser.opts.allow_undefined = true;
+        parser.add_hook("test", () => "hello");
+        const output = parser.get();
+
+        util.assert.strictEqual(output, "<html><body>hello</body></html>\n\n");
+    });
+    it("should allow for hooks to be used in HTML with advanced hooks", () => {
+        util.put(
+            "<html><body>#mdadvhook<test>\n<b>Bold</b>\n<p>Paragraph</p>\n#mdendhook</body></html>",
+            "sample1.html"
+        );
+
+        const replacer = (arg) => {
+            const elem = new util.html.HTMLElement("p", {});
+            elem.set_content("complete");
+            return elem;
+        };
+
+        const parser = new util.Parser("test/test-files/sample1.html");
+        parser.opts.allow_undefined = true;
+        parser.add_adv_hook("test", replacer);
+        const output = parser.get();
+
+        util.assert.strictEqual(
+            output,
+            "<html><body><p>complete</p></body></html>\n\n"
+        );
+    });
+    it("should allow for extracting a node from the document as a template manually with ids", () => {
+        util.put(
+            `<html><body>#mdadvhook<template><name id="b"></name><class id="p"></class>#mdendhook</body></html>`,
+            "sample1.html"
+        );
+
+        const replacer = (elem) => {
+            const nameElem = elem.getElementsByTagName("name")[0];
+            nameElem.tagName = nameElem.id;
+            nameElem.removeAttribute("id");
+            nameElem.set_content("bold");
+            const classElem = elem.getElementsByTagName("class")[0];
+            classElem.tagName = classElem.id;
+            classElem.removeAttribute("id");
+            classElem.set_content("paragraph");
+            return elem;
+        };
+
+        const parser = new util.Parser("test/test-files/sample1.html");
+        parser.opts.allow_undefined = true;
+        parser.add_adv_hook("template", replacer);
+        const output = parser.get();
+
+        util.assert.strictEqual(
+            output,
+            "<html><body><b>bold</b><p>paragraph</p></body></html>\n\n"
+        );
+    });
+    it("should allow for extracting a node from the document as a template using map and data-tags", () => {
+        util.put(
+            `<html><body>#mdadvhook<template><name data-tag="b"></name><class data-tag="p"></class>#mdendhook</body></html>`,
+            "sample1.html"
+        );
+
+        const replacer = (elem, map) => {
+            map["name"].set_content("bold");
+            map["class"].set_content("paragraph");
+            return elem;
+        };
+
+        const parser = new util.Parser("test/test-files/sample1.html");
+        parser.opts.allow_undefined = true;
+        parser.add_adv_hook("template", replacer);
+        const output = parser.get();
+
+        util.assert.strictEqual(
+            output,
+            "<html><body><b>bold</b><p>paragraph</p></body></html>\n\n"
+        );
+    });
+});

package/test/line.test.js

@@ -3,7 +3,7 @@ const util = require("./tester.test");
 describe("Managing blank lines", () => {
     it("should always end with 2 blank lines, even with no input", () => {
         const output = new util.Parser("").get();
-        util.assert.strictEqual(output, "\n\n")
+        util.assert.strictEqual(output, "\n\n");
     });
 
     it("should reduce blank lines to 2", () => {
@@ -16,8 +16,6 @@ describe("Managing blank lines", () => {
 
     it("should allow words when removing blank lines", () => {
         const output = new util.Parser("hii\n\n\n").get();
-        util.assert.strictEqual(output, "hii\n\n")
+        util.assert.strictEqual(output, "hii\n\n");
     });
 });
-
-

package/test/target.test.js

@@ -1,35 +1,43 @@
 const util = require("./tester.test.js");
 
 describe("Target specific functionality", () => {
-
-	describe("HTML", () => {
-		it("Should include `#mdlabel` command, when compiling HTML", () => {
-			const parser = new util.Parser("#mdlabel<0,Cool!>");
-			const html = parser.get(util.TargetType.HTML);
-
-			util.assert.strictEqual(html, '<span id="cool"></span>\n\n')
-		});
-
-		it("Should link to sections with #mdref", () => {
-			const parser = new util.Parser("#mdlabel<0,Cool!>\n#mdlabel<1,coolzz>\n#mdref<Cool!>");
-			const html = parser.get(util.TargetType.HTML);
-
-			util.assert.strictEqual(html, '<span id="cool"></span>\n<span id="coolzz"></span>\n<a href="#cool">Cool!</a>\n\n');
-		})
-	});
-
-	describe("Markdown", () => {
-		it("Should not include `#mdlabel` command, when compiling Markdown", () => {
-			const parser = new util.Parser("#mdlabel<0,Cool!>");
-
-			const md = parser.get(util.TargetType.MARKDOWN);
-			util.assert.strictEqual(md, '\n\n')
-		});
-		it("Should include #mdref to title elements in markdown", () => {
-			const output = new util.Parser("# Some Title!\n#mdref<Some Title!>").get();
-
-			util.assert.strictEqual(output, '# Some Title!\n[Some Title!](#some-title)\n\n')
-		});
-
-	})
-});
+    describe("HTML", () => {
+        it("Should include `#mdlabel` command, when compiling HTML", () => {
+            const parser = new util.Parser("#mdlabel<0,Cool!>");
+            const html = parser.get(util.TargetType.HTML);
+
+            util.assert.strictEqual(html, '<span id="cool"></span>\n\n');
+        });
+
+        it("Should link to sections with #mdref", () => {
+            const parser = new util.Parser(
+                "#mdlabel<0,Cool!>\n#mdlabel<1,coolzz>\n#mdref<Cool!>"
+            );
+            const html = parser.get(util.TargetType.HTML);
+
+            util.assert.strictEqual(
+                html,
+                '<span id="cool"></span>\n<span id="coolzz"></span>\n<a href="#cool">Cool!</a>\n\n'
+            );
+        });
+    });
+
+    describe("Markdown", () => {
+        it("Should not include `#mdlabel` command, when compiling Markdown", () => {
+            const parser = new util.Parser("#mdlabel<0,Cool!>");
+
+            const md = parser.get(util.TargetType.MARKDOWN);
+            util.assert.strictEqual(md, "\n\n");
+        });
+        it("Should include #mdref to title elements in markdown", () => {
+            const output = new util.Parser(
+                "# Some Title!\n#mdref<Some Title!>"
+            ).get();
+
+            util.assert.strictEqual(
+                output,
+                "# Some Title!\n[Some Title!](#some-title)\n\n"
+            );
+        });
+    });
+});

package/test/tester.test.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 const assert = require("assert");
 const Parser = require("../build/parse");
 const path = require("path");
+const html = require("node-html-parser");
 
 /* make folder for temporary files, if it doesn't exist */
 if (
@@ -29,8 +30,9 @@ const TargetType = {
 };
 
 module.exports = {
-    fs,
     assert,
+    fs,
+    html,
     path,
     Parser,
     put,

package/test/vars.test.js

@@ -1,57 +1,49 @@
-const util = require("./tester.test");
+const util = require("./tester.test.js");
 
 describe("Use variables", () => {
-    it('should replace var with the value', () => {
+    it("should replace var with the value", () => {
         const output = new util.Parser("#mddef<hi=yo>\n#mdvar<hi>").get();
 
-        util.assert.strictEqual(output, "\nyo\n\n")
+        util.assert.strictEqual(output, "\nyo\n\n");
     });
-    it('should use variable shorthand', () => {
+    it("should use variable shorthand", () => {
         const output = new util.Parser("#mddef<hi=yo>\n<hi>").get();
 
-        util.assert.strictEqual(output, "\nyo\n\n")
+        util.assert.strictEqual(output, "\nyo\n\n");
     });
-    it('should use variables across files', () => {
+    it("should use variables across files", () => {
         util.put("#mddef<hi=yo>\n#mdinclude<sample2.md>", "sample1.md");
         util.put("<hi>", "sample2.md");
 
         const output = new util.Parser("test/test-files/sample1.md").get();
 
-        util.assert.strictEqual(output, "\nyo\n\n")
-    })
-    it('should throw if undefined variable', () => {
-
+        util.assert.strictEqual(output, "\nyo\n\n");
+    });
+    it("should throw if undefined variable", () => {
         const parser = new util.Parser("<yo>");
 
         let e;
         /* should throw an error */
-        util.assert.throws(
-            () => {
-                try {
-                    parser.get();
-                } catch (_e) {
-                    e = _e;
-                    throw _e;
-                }
+        util.assert.throws(() => {
+            try {
+                parser.get();
+            } catch (_e) {
+                e = _e;
+                throw _e;
             }
-        );
-
-
-
+        });
     });
 
-    it('should preserve whatever comes after', () => {
+    it("should preserve whatever comes after", () => {
         const output = new util.Parser("#mddef<hi=yo>\n<hi>,").get();
         util.assert.strictEqual(output, "\nyo,\n\n");
     });
 
-    it('should replace underscore with space', () => {
-        const output = new util.Parser("#mddef<name=Mr_Sir>\n#mdvar<name>").get();
+    it("should replace underscore with space", () => {
+        const output = new util.Parser(
+            "#mddef<name=Mr_Sir>\n#mdvar<name>"
+        ).get();
 
-        util.assert.strictEqual(output, "\nMr Sir\n\n")
+        util.assert.strictEqual(output, "\nMr Sir\n\n");
     });
-
 });
-
-
-

package/build/cltool.d.ts

@@ -1 +0,0 @@
-export declare const argParser: any;