markdown-maker 1.10.2 → 1.10.3

package/src/templates.ts

@@ -1,3 +1,5 @@
+import { MDMError, MDMNonParserError } from "./errors";
+
 const templates: { [key: string]: string } = {};
 
 /**
@@ -6,7 +8,9 @@ const templates: { [key: string]: string } = {};
  * @param content The replacement string
  */
 export function new_template(name: string, content: string) {
-    templates[name] = content;
+	if (name in templates)
+		throw new MDMNonParserError(`Template "${name}" already exists`);
+	templates[name] = content;
 }
 
 /* initialize default templates */

package/src/types.ts

@@ -0,0 +1,33 @@
+import { HTMLElement } from "node-html-parser";
+import { Command } from "./commands";
+
+export type CommandGroupType = {
+	preparse: Command[];
+	parse: Command[];
+	postparse: Command[];
+};
+
+type TaggedElementArguments = {
+	repeat?: number;
+};
+
+export type TaggedElement = {
+	"html-tag": string;
+	"var-tag": string;
+	_raw: string;
+	args: TaggedElementArguments;
+	node: HTMLElement;
+};
+
+export enum CommandType {
+	PREPARSE,
+	PARSE,
+	POSTPARSE,
+}
+
+export enum TargetType {
+	HTML,
+	MARKDOWN,
+}
+
+export type Checksum = string;

package/tests/_test-util.ts

@@ -0,0 +1,44 @@
+import fs from "fs";
+import Parser from "../src/parser";
+import path from "path";
+import { expect, jest, test } from "@jest/globals";
+import { TargetType } from "../src/types";
+
+beforeAll(() => {
+	return new Promise((res, rej) => {
+		fs.mkdir(path.join("tests", "test-files"), res);
+	});
+});
+// afterAll(() => {
+// 	return new Promise((res, rej) => {
+// 		fs.rm(path.join("tests", "test-files"), { recursive: true }, res);
+// 	});
+// });
+
+function put(text: string | NodeJS.ArrayBufferView, file: string) {
+	fs.writeFileSync(path.join("tests", "test-files", file), text);
+}
+function putDir(name: string) {
+	fs.mkdirSync(path.join("tests", "test-files", name));
+}
+
+beforeEach(() => {
+	return new Promise((res, rej) => {
+		fs.mkdir("tests/test-files", res);
+	});
+});
+
+afterEach(() => {
+	return new Promise((res, rej) => {
+		fs.rm("tests/test-files", { recursive: true }, res);
+	});
+});
+
+export default {
+	expect,
+	path,
+	Parser,
+	put,
+	putDir,
+	TargetType,
+};

package/tests/advanced.spec.ts

@@ -0,0 +1,92 @@
+import util from "./_test-util";
+
+describe("Use of templates", function () {
+	it("should import presentation template as expected", function () {
+		const output = new util.Parser("#mdtemplate<presentation>").get();
+		const template = `<style>html {width: 100vw;height: 100vh;}.slide {padding: 5%;border-radius: 25px;margin: 0;}div > .slide-num {position: absolute;top: 12.5%;right: 15%;/* font-size: 150%; */}body {margin: 5% 15%;}img {max-width: 100%;max-height: 40vh;}</style><script>document.addEventListener("DOMContentLoaded", () => {let current_slide = 0;const all_slides = document.querySelectorAll("div.slide");const num_slides = all_slides.length;all_slides.forEach((slide) => {const num_elem = document.createElement("p");num_elem.classList.add("slide-num");slide.appendChild(num_elem);});onkeydown = (ev) => {if (ev.key == "ArrowRight" && current_slide < all_slides.length - 1)update_slide(++current_slide);else if (ev.key == "ArrowLeft" && current_slide > 0)update_slide(--current_slide);};const update_slide = (index) => {all_slides.forEach((slide) => (slide.style.display = "none"));all_slides[current_slide].style.display = "block";all_slides[current_slide].lastChild.textContent = \`\${current_slide + 1} / \${num_slides}\`;};update_slide(current_slide);});</script>`;
+
+		util.expect(output).toBe(template + "\n\n");
+	});
+
+	it("should use custom templates from project extensions.js file", () => {
+		util.put(
+			"module.exports = {main: (new_template, _) => {new_template('hi', 'hello');}};",
+			"extensions.js"
+		);
+		util.put("#mdtemplate<hi>", "sample1.md");
+
+		util.expect(new util.Parser("tests/test-files/sample1.md").get()).toBe(
+			"hello\n\n"
+		);
+	});
+
+	it("should use custom commands from project extensions.js file", () => {
+		util.put(
+			'module.exports = {main: (_, new_command) => {new_command(/#teep/, () => "#peet")}};',
+			"extensions.js"
+		);
+		util.put("#teep", "sample1.md");
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+		const output = parser.get();
+
+		util.expect(output).toEqual("#peet\n\n");
+	});
+});
+
+describe("Use of markdown hooks for SSR", () => {
+	it("should allow hooks hooks to be used", () => {
+		util.put("#mdhook<t1>\n<p::var>\n#mdendhook<t1>", "sample1.md");
+
+		const parser = new util.Parser("tests/test-files/sample1.md", {
+			allow_undefined: true,
+		});
+		parser.add_hook("t1", (map) => {
+			map["var"].node.textContent = "complete";
+		});
+
+		const output = parser.get();
+
+		util.expect(output).toBe("<p>complete</p>\n\n");
+	});
+
+	it("should allow for extracting a node from the document as a template using map", () => {
+		util.put(
+			`<html><body>#mdhook<template><b::name><p::class>#mdendhook<template></body></html>`,
+			"sample1.html"
+		);
+
+		const parser = new util.Parser("tests/test-files/sample1.html", {
+			allow_undefined: true,
+		});
+
+		parser.add_hook("template", (map) => {
+			map["name"].node.textContent = "bold";
+			map["class"].node.textContent = "paragraph";
+		});
+		const output = parser.get();
+
+		util.expect(output).toBe(
+			"<html><body><b>bold</b><p>paragraph</p></body></html>\n\n"
+		);
+	});
+	it("should allow for nested hooks to be used", () => {
+		util.put(
+			"#mdhook<t1><p::outer1>#mdhook<t2><p::inner>#mdendhook<t2><p::outer2>#mdendhook<t1>",
+			"sample1.md"
+		);
+
+		const parser = new util.Parser("tests/test-files/sample1.md", {});
+		parser.add_hook("t1", (map) => {
+			map["outer1"].node.textContent = "hello";
+			map["outer2"].node.textContent = "world";
+		});
+		parser.add_hook("t2", (map) => {
+			map["inner"].node.textContent = "!";
+		});
+
+		const output = parser.get();
+
+		util.expect(output).toBe("<p>hello</p><p>!</p><p>world</p>\n\n");
+	});
+});

package/tests/basic.spec.ts

@@ -0,0 +1,68 @@
+import util from "./_test-util";
+import { MDMError } from "../src/errors";
+
+describe("Basic features", () => {
+	it("should join two files with include", () => {
+		util.put("hello\n#mdinclude<sample2.md>", "sample1.md");
+		util.put("there", "sample2.md");
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+		const output = parser.get();
+
+		util.expect(output).toEqual("hello\nthere\n\n");
+	});
+	it("should make a table of contents", () => {
+		const output = new util.Parser(
+			"# yo\n## bruh nugget\n#mdmaketoc"
+		).get();
+
+		util.expect(output).toBe(
+			"# yo\n## bruh nugget\n* [yo](#yo)\n  * [bruh nugget](#bruh-nugget)\n\n"
+		);
+	});
+	it("should allow quotation marks in titles for toc", () => {
+		const parser = new util.Parser("# mac's farm\n#mdmaketoc");
+		const markdown = parser.get();
+
+		util.expect(markdown).toBe(
+			"# mac's farm\n* [mac's farm](#macs-farm)\n\n"
+		);
+	});
+	it("should allow variables in toc", () => {
+		const output = new util.Parser(
+			"#mddef<name=Foobar>\n# mr. #mdvar<name>\n#mdmaketoc<>"
+		).get();
+
+		util.expect(output).toBe(
+			"\n# mr. Foobar\n* [mr. Foobar](#mr-foobar)\n\n"
+		);
+	});
+	it("should not exceed max include depth", () => {
+		util.put("#mdinclude<sample2.md>", "sample1.md");
+		util.put("yo.md>", "sample2.md");
+
+		function get() {
+			const parser = new util.Parser("tests/test-files/sample1.md", {
+				max_depth: 0,
+			});
+			parser.get();
+		}
+
+		util.expect(get).toThrow(MDMError);
+	});
+	it("should be able to reference toc elements, even if they are below toc-level", () => {
+		const parser = new util.Parser(`### Title\n#mdref<Title>`);
+
+		util.expect(parser.get()).toBe("### Title\n[Title](#title)\n\n");
+	});
+	it("should include file with same name as folder when including a folder", () => {
+		util.put("#mdinclude<sample_fld>", "sample1.md");
+		util.putDir("sample_fld");
+		util.put("hello", util.path.join("sample_fld", "sample_fld.md"));
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+		const output = parser.get();
+
+		util.expect(output).toBe("hello\n\n");
+	});
+});

package/tests/clargs.spec.ts

@@ -0,0 +1,50 @@
+import util from "./_test-util";
+
+describe("Command Line Arguments", () => {
+	it("--use-underscore should replace '-' with '_' in toc", () => {
+		const output = new util.Parser("# foo bar\n#mdmaketoc", {
+			use_underscore: true,
+		}).get();
+
+		util.expect(output).toBe("# foo bar\n* [foo bar](#foo_bar)\n\n");
+	});
+	it("--toc-level should exclude subsection with lower level", () => {
+		const output = new util.Parser("# foo bar\n### baz\n#mdmaketoc", {
+			toc_level: 2,
+		}).get();
+
+		util.expect(output).toBe(
+			"# foo bar\n### baz\n* [foo bar](#foo-bar)\n\n"
+		);
+	});
+	it("--allow-undef should not throw when variable is not defined", () => {
+		const output = new util.Parser("#mdvar<zum>", {
+			allow_undefined: true,
+		}).get();
+
+		util.expect(output).toBe("<zum>\n\n");
+	});
+});
+describe("Conditional imports", () => {
+	it("should be able to conditionally import documents", () => {
+		util.put("hello\n#mdinclude<sample2.md, YES>", "sample1.md");
+		util.put("there", "sample2.md");
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+		parser.opts.args.push("YES");
+
+		const output = parser.get();
+
+		util.expect(output).toBe("hello\nthere\n\n");
+	});
+	it("shouldn't include a document when flag is unset", () => {
+		util.put("hello\n#mdinclude<sample2.md,YES>", "sample1.md");
+		util.put("there", "sample2.md");
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+
+		const output = parser.get();
+
+		util.expect(output).toBe("hello\n\n");
+	});
+});

package/tests/errors.spec.ts

@@ -0,0 +1,64 @@
+import { MDMError, MDMNonParserError } from "../src/errors";
+import util from "./_test-util";
+
+describe("Error handling", () => {
+	it("should dissallow undefined templates", () => {
+		util.put("#mdtemplate<UNDEF>", "sample1.md");
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+
+		let answer =
+			'Template "UNDEF" not found!' +
+			"\n...on line 1 in tests/test-files/sample1.md".grey(15);
+
+		util.expect(() => parser.get()).toThrow(MDMError);
+	});
+	it("should dissallow loading a folder without an entry file", () => {
+		util.put("#mdinclude<sample_fld>", "sample1.md");
+		util.putDir("sample_fld");
+
+		function get() {
+			const parser = new util.Parser("tests/test-files/sample1.md");
+			parser.get();
+		}
+
+		let answer =
+			'No entry file found in folder "sample_fld". Looking for "tests/test-files/sample_fld/sample_fld.md"' +
+			"\n...on line 1 in tests/test-files/sample1.md".grey(15);
+
+		util.expect(get).toThrow(MDMError);
+		util.expect(get).toThrow(answer);
+	});
+	it("should dissallow adding more than one hook with the same name", () => {
+		const parser = new util.Parser("tests/test-files/sample1.md");
+
+		parser.add_hook("test", () => {});
+		util.expect(() => parser.add_hook("test", () => {})).toThrow(
+			MDMNonParserError
+		);
+	});
+	describe("Duplicate key errors", () => {
+		it("should dissallow adding more than one template with the same name", () => {
+			/*  */
+			util.put(
+				`module.exports = {main: (new_template, new_command) =>
+					{
+						new_template('test', 'hello');
+						new_template('test', 'hello');
+					}
+				};`,
+				"extensions.js"
+			);
+
+			util.put("", "sample1.md");
+
+			function get() {
+				const parser = new util.Parser("tests/test-files/sample1.md");
+				parser.get();
+			}
+
+			util.expect(get).toThrow(MDMNonParserError);
+			util.expect(get).toThrow('Template "test" already exists');
+		});
+	});
+});

package/tests/html.spec.ts

@@ -0,0 +1,23 @@
+import util from "./_test-util";
+
+describe("HTML Emitting", () => {
+	it("should generate valid html", () => {
+		const parser = new util.Parser("# cool title\nwith a cool paragraph");
+		parser.opts.html = true;
+
+		const output = parser.html();
+
+		util.expect(output).toBe(
+			'<h1 id="cool-title">cool title</h1><p>with a cool paragraph</p>\n'
+		);
+	});
+	it("should be able to include html documents, and not parse", () => {
+		util.put("#mdinclude<sample2.html>", "sample1.md");
+		util.put("#mdvar<lul>", "sample2.html");
+
+		const parser = new util.Parser("tests/test-files/sample1.md");
+		const output = parser.get();
+
+		util.expect(output).toBe("#mdvar<lul>\n\n");
+	});
+});

package/tests/line.spec.ts

@@ -0,0 +1,21 @@
+import util from "./_test-util";
+
+describe("Managing blank lines", () => {
+	it("should always end with 2 blank lines, even with no input", () => {
+		const output = new util.Parser("").get();
+		util.expect(output).toBe("\n\n");
+	});
+
+	it("should reduce blank lines to 2", () => {
+		const output1 = new util.Parser("\n\n\n\n").get();
+		util.expect(output1).toBe("\n\n");
+
+		const output2 = new util.Parser("\n\n\n\nHello!").get();
+		util.expect(output2).toBe("\n\nHello!\n\n");
+	});
+
+	it("should allow words when removing blank lines", () => {
+		const output = new util.Parser("hii\n\n\n").get();
+		util.expect(output).toBe("hii\n\n");
+	});
+});

package/tests/marked.spec.ts

@@ -0,0 +1,40 @@
+import util from "./_test-util";
+
+describe("Marked extentions", () => {
+	it("should add a single class to blockquotes", () => {
+		const parser = new util.Parser("> hello {.one}", {
+			use_underscore: true,
+			html: true,
+		});
+
+		const output = parser.html();
+
+		util.expect(output).toBe(
+			'<blockquote class="one" >\n<p>hello </p></blockquote>'
+		);
+	});
+	it("should add multiple class to blockquotes", () => {
+		const parser = new util.Parser("> hello {.one .two}", {
+			use_underscore: true,
+			html: true,
+		});
+
+		const output = parser.html();
+
+		util.expect(output).toBe(
+			'<blockquote class="one two" >\n<p>hello </p></blockquote>'
+		);
+	});
+	it("should add a single class and id to blockquotes", () => {
+		const parser = new util.Parser("> hello {.one #myid}", {
+			use_underscore: true,
+			html: true,
+		});
+
+		const output = parser.html();
+
+		util.expect(output).toBe(
+			'<blockquote class="one" id="myid">\n<p>hello </p></blockquote>'
+		);
+	});
+});

package/tests/target.spec.ts

@@ -0,0 +1,41 @@
+import util from "./_test-util";
+
+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.expect(html).toBe('<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.expect(html).toBe(
+				'<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.expect(md).toBe("\n\n");
+		});
+		it("Should include #mdref to title elements in markdown", () => {
+			const output = new util.Parser(
+				"# Some Title!\n#mdref<Some Title!>"
+			).get();
+
+			util.expect(output).toBe(
+				"# Some Title!\n[Some Title!](#some-title)\n\n"
+			);
+		});
+	});
+});

package/tests/vars.spec.ts

@@ -0,0 +1,45 @@
+import { MDMError } from "../src/errors";
+import util from "./_test-util";
+
+describe("Use variables", () => {
+	it("should replace var with the value", () => {
+		const output = new util.Parser("#mddef<hi=yo>\n#mdvar<hi>").get();
+
+		util.expect(output).toBe("\nyo\n\n");
+	});
+	it("should use variable shorthand", () => {
+		const output = new util.Parser("#mddef<hi=yo>\n!<hi>").get();
+
+		util.expect(output).toBe("\nyo\n\n");
+	});
+	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("tests/test-files/sample1.md").get();
+
+		util.expect(output).toBe("\nyo\n\n");
+	});
+	it("should throw if undefined variable", () => {
+		const parser = new util.Parser("!<yo>");
+
+		/* should throw an error */
+		function get() {
+			parser.get();
+		}
+		util.expect(get).toThrow();
+	});
+
+	it("should preserve whatever comes after", () => {
+		const output = new util.Parser("#mddef<hi=yo>\n!<hi>,").get();
+		util.expect(output).toBe("\nyo,\n\n");
+	});
+
+	it("should replace underscore with space", () => {
+		const output = new util.Parser(
+			"#mddef<name=Mr_Sir>\n#mdvar<name>"
+		).get();
+
+		util.expect(output).toBe("\nMr Sir\n\n");
+	});
+});