markdown-maker 1.10.1 → 1.10.3

package/src/main.ts

@@ -0,0 +1,123 @@
+import path from "path";
+import { WebSocketServer } from "ws";
+import * as fs from "fs";
+
+import choki from "chokidar";
+import Parser from "./parser";
+
+/* for adding colours to strings */
+import { enable as ColorsEnable } from "colors.ts";
+ColorsEnable();
+
+import { argParser, CommandLineArgs, ParserOptions } from "./cltool";
+const configFileName = ".mdmconfig.json";
+
+function main() {
+	let clargs: CommandLineArgs;
+	let server: WebSocketServer | undefined;
+
+	/* Read config file or parse args from cmd-line */
+	if (fs.existsSync(configFileName)) {
+		let data: CommandLineArgs = JSON.parse(
+			fs.readFileSync(configFileName).toString()
+		).opts;
+
+		let args: (string | number)[] = [];
+		Object.entries(data).forEach(([key, value]) => {
+			if (key != "src" && value !== false) {
+				args.push("--" + key);
+			}
+			if (typeof value != "boolean") {
+				args.push(value);
+			}
+		});
+
+		/* We skip [0] and [1], as  it is the binary and source file, even when compiled*/
+		for (let i = 2; i < process.argv.length; i++)
+			args.push(process.argv[i]);
+
+		clargs = argParser.parse_args(args.map((x) => x.toString()));
+	} else {
+		clargs = argParser.parse_args();
+	}
+
+	/* if src is init, create config file and exit */
+	if (clargs.src == "init") {
+		const template = fs.readFileSync(
+			path.join(
+				__dirname,
+				"..",
+				"src",
+				"templates",
+				"configTemplate.json"
+			)
+		);
+		fs.writeFileSync(configFileName, template);
+		fs.writeFileSync("main.md", "# Main\n");
+		return;
+	}
+
+	/* helper method for calling parser */
+	const compile = (source, output, cb?) => {
+		/* load data from file, if it exists,
+		 * otherwise, interpret as string */
+
+		const parser = new Parser(source, clargs);
+		parser.to(output, (file) => {
+			console.log(`Compiled ${file}`.green);
+			if (cb) cb();
+		});
+		return parser;
+	};
+
+	const internalCooldown = 1000;
+	function watcher(_, path: string) {
+		const now = Date.now();
+
+		if (!this.time) this.time = now;
+		if (now - this.time < internalCooldown) return;
+		console.log(`Detected change in ${path}...`);
+		try {
+			compile(clargs.src, clargs.output, () => {
+				/* after compile, send refresh command to clients */
+				server.clients.forEach((client) => {
+					if (client.OPEN) client.send("refresh");
+				});
+			});
+		} catch (e) {
+			console.log(e.message);
+		}
+
+		this.time = now;
+	}
+
+	/* in case source is a directory, look for entry in directory */
+	if (fs.existsSync(clargs.src) && fs.lstatSync(clargs.src).isDirectory()) {
+		clargs.src = path.join(clargs.src, clargs.entry);
+	}
+
+	if (clargs.debug) console.dir(clargs);
+
+	/* compile once if not watching 
+       otherwise watch the folder and recompile on change */
+	if (!clargs.watch) compile(clargs.src, clargs.output);
+	else {
+		const srcDirName = path.dirname(clargs.src);
+		console.log(`Watching ${srcDirName} for changes...`.yellow);
+		server = new WebSocketServer({ port: 7788 });
+
+		const _watcher = choki.watch(srcDirName).on("all", watcher);
+		try {
+			compile(clargs.src, clargs.output);
+		} catch (e) {
+			console.log(e.message);
+		}
+	}
+}
+export default {
+	Parser,
+};
+/* main entrypoint */
+if (require.main === module) {
+	main();
+}

package/src/parser.ts

@@ -0,0 +1,398 @@
+import fs from "fs"; /* for handling reading of files */
+import path from "path"; /* for handling file paths */
+
+import marked from "marked";
+
+import { Command, commands, load_extensions } from "./commands";
+import {
+	argParser,
+	IncompleteCommandLineArgs,
+	IncompleteParserOptions,
+	ParserOptions,
+} from "./cltool";
+import { MDMError, MDMNonParserError, MDMWarning } from "./errors";
+import { CommandGroupType, TaggedElement, TargetType } from "./types";
+
+/* parse some md
+ * recursively with extra options */
+class Parser {
+	file: string;
+	parent?: Parser;
+	line_num: number;
+	wd: string;
+	wd_full: string;
+	blobs: {
+		[key: number]: string | undefined;
+	};
+	opts: ParserOptions;
+	raw: string;
+
+	static TOKEN = "#md";
+
+	constructor(
+		filename: string,
+		clargs?: IncompleteCommandLineArgs,
+		opts?: IncompleteParserOptions
+	) {
+		/* this.working_directory */
+		this.file = filename;
+
+		this.line_num = 0;
+		this.wd = path.dirname(filename);
+		this.wd_full = path.resolve(this.wd);
+
+		/* finished blob */
+		this.blobs = {};
+
+		if (!clargs) {
+			clargs = argParser.parse_args([filename]);
+		}
+
+		/* get default options, and overwrite with the ones present
+           in the arguments */
+		this.opts = defaultParserOptions();
+		Object.assign(this.opts, clargs);
+		Object.assign(this.opts, opts);
+
+		this.raw = this.opts.isFileCallback(filename) || filename;
+	}
+
+	private parse() {
+		load_extensions(this);
+		if (this.opts.verbose || this.opts.debug) {
+			console.log(
+				`parsing ${this.file}: depth=${this.opts.depth}`.magenta
+			);
+		}
+
+		if (this.opts.debug) {
+			console.log("Parsing options:");
+			console.log(this.opts);
+		}
+
+		/* reset sections for beginning parse */
+		if (this.opts.depth === 0) this.opts.secs = [];
+		let __blob = this.raw;
+
+		/* apply preproccessing to raw file */
+		__blob = this.preprocess(__blob);
+
+		/* main parser instance call */
+		__blob = this.mainparse(__blob);
+
+		/**
+		 * apply postprocessing after */
+		__blob = this.postprocess(__blob);
+
+		return __blob;
+	}
+
+	private mainparse(blob: string) {
+		if (this.opts.verbose || this.opts.debug) {
+			console.debug(`beginning mainparse of '${this.file}'`.blue);
+		}
+
+		/* main parser instance loop */
+		blob.split("\n").forEach((line, lnum) => {
+			this.line_num = lnum;
+
+			/* if line looks like a title */
+			const titleMatch = line.trim().match(/^(#+) (.+)$/);
+
+			if (titleMatch) {
+				if (this.opts.verbose || this.opts.debug)
+					console.log("found toc element: " + line);
+
+				/* implement toc level */
+				let level = titleMatch[1].length;
+				let title = titleMatch[2];
+
+				this.opts.secs.push({ level, title });
+
+				if (this.opts.debug) {
+					console.log("updated sections:", { level, title });
+				}
+			}
+		});
+
+		return this.parse_commands(blob, commands.parse);
+	}
+
+	private preprocess(blob: string) {
+		if (this.opts.verbose || this.opts.debug) {
+			console.debug(`beginning preprocess of '${this.file}'`.blue);
+		}
+
+		return this.parse_commands(blob, commands.preparse);
+	}
+
+	private postprocess(blob: string) {
+		if (this.opts.verbose || this.opts.debug) {
+			console.debug(`beginning postprocess of '${this.file}'`.blue);
+		}
+
+		blob = this.parse_commands(blob, commands.postparse);
+
+		/* remove double empty lines */
+		blob = this.remove_double_blank_lines(blob);
+		blob = blob.trimEnd() + "\n\n";
+		return blob;
+	}
+
+	private parse_commands(blob: string, commands: Command[]) {
+		commands.forEach((command) => {
+			/* Add global flag to RegExp */
+			const re = new RegExp(
+				command.validator.source,
+				(command.validator.flags || "") + "g"
+			);
+
+			const replacer = (args: RegExpExecArray) => {
+				try {
+					return command.act(args, this) || "";
+				} catch (error) {
+					switch (true) {
+						case error instanceof MDMError:
+							throw error;
+						case error instanceof MDMWarning:
+							console.warn(error.message);
+							return `**Warning: ${error.message}**`;
+						default:
+							console.error(error);
+							throw error;
+					}
+				}
+			};
+
+			/*  */
+
+			let match: RegExpExecArray | null;
+			while ((match = re.exec(blob)) !== null) {
+				blob =
+					blob.slice(0, match.index) +
+					replacer(match) +
+					blob.slice(match.index + match[0].length);
+			}
+		});
+		return blob;
+	}
+
+	/* Parse all commands sequentially on a sub-blob */
+	private parse_all_commands(blob: string, commands: CommandGroupType) {
+		blob = this.parse_commands(blob, commands.preparse);
+		blob = this.parse_commands(blob, commands.parse);
+		blob = this.parse_commands(blob, commands.postparse);
+		return blob;
+	}
+
+	titleId(title: string) {
+		const sep = this.opts.use_underscore ? "_" : "-";
+
+		title = title
+			.toLowerCase()
+			.replace(/[^\w\s]+/g, "")
+			.replace(/[\s_]+/g, sep);
+		return title;
+	}
+
+	get_toc() {
+		let __blob = [];
+		let tabSize = 2;
+		const beg = "* ";
+		const hor = " ".repeat(tabSize);
+
+		this.opts.secs.forEach((sec) => {
+			if (sec.level > this.opts.toc_level) return;
+			let title = sec.title.replace(/_/g, " ");
+			title = this.parse_all_commands(title, commands);
+			const link = this.titleId(title);
+
+			let __line =
+				hor.repeat(Math.max(sec.level - 1, 0)) +
+				beg +
+				`[${title}](#${link})`;
+
+			__blob.push(__line);
+		});
+		return __blob.join("\n");
+	}
+
+	add_hook(
+		name: string,
+		hook: (map: { [key: string]: TaggedElement }) => void
+	) {
+		if (this.opts.hooks[name] != undefined)
+			throw new MDMNonParserError(`Hook "${name}" already exists!`);
+		this.opts.hooks[name] = hook;
+	}
+
+	private line_num_from_index(index: number) {
+		return this.raw.substring(0, index).split("\n").length;
+	}
+
+	private remove_double_blank_lines(blob) {
+		/* replace all triple newlines, and EOF by double newline */
+		blob = blob.replace(/(\r\n|\n){3,}/g, "\n\n");
+
+		return blob;
+	}
+
+	/* output the parsed document to bundle */
+	to(bundleName: string, callback: (fileName: string) => void) {
+		const dir = path.dirname(bundleName);
+		if (callback === undefined) callback = () => {};
+
+		if (!fs.existsSync(dir)) {
+			fs.mkdirSync(dir, { recursive: true });
+		}
+
+		if (!this.opts.html) {
+			this.get(TargetType.MARKDOWN, (blob) => {
+				fs.writeFile(bundleName, blob, () => callback(bundleName));
+			});
+		} else {
+			const htmlFileName = bundleName.replace(".md", ".html");
+			fs.writeFile(htmlFileName, this.html(), () =>
+				callback(htmlFileName)
+			);
+		}
+	}
+
+	html() {
+		const htmlFormatted = marked
+			.parse(this.get(TargetType.HTML))
+			.toString();
+		if (this.opts.watch) {
+			return (
+				`<script>` +
+				`w=new WebSocket("ws:localhost:7788");` +
+				`w.addEventListener("message",(e)=>` +
+				`   {if(e.data=="refresh")location.reload();}` +
+				`);` +
+				`</script>\n` +
+				htmlFormatted
+			);
+		}
+		return htmlFormatted;
+	}
+
+	createChild(file: string) {
+		return new Parser(file, undefined, {
+			parent: this,
+			depth: this.opts.depth + 1,
+			...this.opts,
+		});
+	}
+
+	get(targetType?: TargetType, callback?: (blob: string) => void): string {
+		/* If target type is undefined, markdown is the default */
+		if (targetType === undefined) targetType = TargetType.MARKDOWN;
+		if (this.blobs[targetType]) {
+			if (callback) {
+				callback(this.blobs[targetType]);
+			}
+			return this.blobs[targetType];
+		} else {
+			try {
+				this.opts.targetType = targetType;
+				let blob = this.parse();
+				this.opts.targetType = undefined;
+				if (callback) callback(blob);
+				return blob;
+			} catch (error) {
+				/* Compile a traceback of error */
+				let traceback = "";
+				let p: Parser = this;
+
+				do {
+					if (error instanceof MDMError)
+						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);
+					if (p.parent) p = p.parent;
+				} while (p.parent);
+
+				error.message += traceback;
+
+				/* only interested in node stacktrace when debugging */
+				if (!this.opts.debug) error.stack = "";
+
+				if (this.opts.only_warn) console.error(error);
+				else throw error;
+			}
+		}
+	}
+}
+
+function defaultParserOptions(): ParserOptions {
+	return {
+		defs: {},
+		secs: [],
+		args: [],
+		depth: 0,
+		verbose: false,
+		debug: false,
+		max_depth: 5,
+		use_underscore: false,
+		toc_level: 3,
+		allow_undefined: false,
+		html: false,
+		watch: false,
+		targetType: undefined,
+		only_warn: false,
+		parent: undefined,
+		hooks: {},
+		isFileCallback: (f) => {
+			if (!fs.existsSync(f)) return false;
+			return fs.readFileSync(f, "utf-8") + "\n";
+		},
+	};
+}
+
+export function splice(
+	str: string,
+	startIndex: number,
+	width: number,
+	newSubStr: string
+) {
+	const start = str.slice(0, startIndex);
+	const end = str.slice(startIndex + width);
+	return start + newSubStr + end;
+}
+
+/* add extention to marked for classed blockquotes*/
+marked.use({
+	renderer: {
+		blockquote(quote: string) {
+			/* find the ending, and if not, return the default */
+			const ending = quote.match(/\{(.+)\}\s*<\/p>/);
+			if (!ending) return `<blockquote>${quote}</blockquote>`;
+
+			const args = ending[1].split(" ");
+
+			const classes = args.filter((arg) => arg.startsWith("."));
+			const id = args.filter((arg) => arg.startsWith("#"));
+
+			const classNames = classes.map((c) => c.slice(1));
+			const classText =
+				classes.length > 0 ? `class="${classNames.join(" ")}"` : "";
+			const idText = id.length > 0 ? `id="${id[0].slice(1)}"` : "";
+
+			/* remove the ending from the quote */
+			quote = quote.replace(/\{(.+)\}\s*<\/p>/, "</p>");
+
+			return `<blockquote ${classText} ${idText}>\n${quote.trim()}</blockquote>`;
+		},
+		heading(text: string, level: number) {
+			/* add an id to each heading */
+			return `<h${level} id="${text
+				.replace(/ /g, "-")
+				.toLowerCase()}">${text}</h${level}>`;
+		},
+	},
+});
+
+export default Parser;

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");
+	});
+});