markdown-maker 1.7.10 → 1.9.1

package/.github/workflows/node.js.yml

@@ -3,11 +3,7 @@
 
 name: Mocha
 
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
+on: [push, pull_request]
 
 jobs:
   build:
@@ -25,6 +21,15 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test
+    - name: yarn install
+      uses: borales/actions-yarn@v3.0.0
+      with:
+        cmd: install # will run `yarn install` command
+    - name: yarn build
+      uses: borales/actions-yarn@v3.0.0
+      with:
+        cmd: build # will run `yarn build` command
+    - name: yarn test
+      uses: borales/actions-yarn@v3.0.0
+      with:
+        cmd: test # will run `yarn test` command

package/README.md

@@ -14,6 +14,7 @@ Currently supports the following features
 * Automatic Table of Contents generation with `#mdmaketoc`
 * HTML emitting with custom styling
 * Easy extention of custom commands, see `src/commands.js` for implementations
+* Usage of templates with the `#mdtemplate<...>` command.
 
 ## Usage
 Download the [latest release](https://github.com/blitzher/markdown-maker/releases), and write your document.

package/doc/.mdmconfig.json

@@ -0,0 +1,7 @@
+{
+    "opts": {
+        "src": "main.md",
+        "use-underscore": true,
+        "html": true
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "markdown-maker",
-    "version": "1.7.10",
+    "version": "1.9.1",
     "description": "",
     "main": "src/cltool.ts",
     "bin": {
@@ -13,8 +13,8 @@
             "node_modules/colors/*",
             "node_modules/colors./*",
             "node_modules/marked/*",
-            "node_modules/open/*",
-            "build/cltool.js"
+            "build/cltool.js",
+            "src/templates/*"
         ],
         "targets": [
             "node12-macos-x64",
@@ -26,7 +26,7 @@
         "test": "mocha",
         "test:yarn": "mocha",
         "bundle": "tsc --project tsconfig.json",
-        "main": "node build/cltool.js document/main.md -o dist/bundle.md",
+        "main": "node build/cltool.js document/main.md -o dist/bundle.md --debug",
         "debug": "node src/cltool.js -db document/main.md -o dist/bundle.md",
         "build": "npm run bundle && pkg --output bin/mdparse .",
         "build:yarn": "yarn bundle && pkg --output bin/mdparse .",
@@ -46,18 +46,20 @@
         "@types/chokidar": "^2.1.3",
         "@types/colors": "^1.2.1",
         "@types/node": "^15.6.1",
+        "@types/ws": "^8.5.3",
         "argparse": "^2.0.1",
         "chokidar": "^3.5.1",
         "colors": "^1.4.0",
         "colors.ts": "^1.0.20",
         "marked": "^2.0.1",
-        "open": "^8.0.5"
+        "require-runtime": "^2.0.0",
+        "ws": "^8.8.1"
     },
     "devDependencies": {
         "cloc": "^2.7.0",
         "mocha": "^8.3.1",
+        "pkg": "^4.4.9",
         "prettier": "^2.3.0",
-        "typescript": "^4.3.2",
-        "pkg": "^4.4.9"
+        "typescript": "^4.3.2"
     }
 }

package/prettierrc.yaml

@@ -1,4 +1,4 @@
-trailingComma: es5
+trailingComma: all
 tabWidth: 4
 singleQuote: true
 arrowParens: always

package/re-test.js

@@ -0,0 +1,10 @@
+const s = "hello1, hello2, hello3";
+
+const re = /hello(?<digit>\d)/g;
+
+let m = s.replace(re, (match, ...args) => {
+	console.log(args);
+	return "world";
+});
+
+console.log({ s, m });

package/src/cltool.ts

@@ -3,6 +3,7 @@ const path = require("path"); /* for handling file paths */
 
 import Colors = require("colors.ts"); /* for adding colours to strings */
 import Parser from "./parse";
+import { WebSocketServer } from "ws";
 
 Colors.enable();
 const { ArgumentParser } = require("argparse"); /* for parsing clargs */
@@ -11,8 +12,11 @@ const choki = require("chokidar");
 
 export const argParser = new ArgumentParser({
     description: "Markdown bundler, with extra options",
+    prog: "mdparse",
 });
 
+const configFileName = ".mdmconfig.json";
+
 //#region command line args
 argParser.add_argument("src", {
     help: "file to be parsed. If this is a directory, it looks for entry point in the directory, see --entry",
@@ -22,7 +26,7 @@ argParser.add_argument("-v", "--verbose", {
     action: "store_true",
     help: "enable verbose output",
 });
-argParser.add_argument("-db", "--debug", {
+argParser.add_argument("-D", "--debug", {
     action: "store_true",
     help: "enable debugging information",
 });
@@ -43,28 +47,50 @@ argParser.add_argument("-w", "--watch", {
     action: "store_true",
     help: "recompile after a change in target target file or directory.",
 });
-argParser.add_argument("-uu", "--use-underscore", {
+argParser.add_argument("-u", "--use-underscore", {
     action: "store_true",
     help: "set the parser to use '_' as seperator in ids for Table of Content. If the links in the table does not work, this is likely to be the issue.",
 });
-argParser.add_argument("--toc-level", {
+argParser.add_argument("-t", "--toc-level", {
     help: "the section level of the table of contents, by default is 3",
     default: 3,
     type: "int",
 });
-argParser.add_argument("--html", {
+argParser.add_argument("-H", "--html", {
     action: "store_true",
     help: "compile HTML from the parsed markdown",
 });
-argParser.add_argument("--allow-undef", "-au", {
+argParser.add_argument("--allow-undefined", "-A", {
     action: "store_true",
-    help: "allow undefined variables. Mostly useful for typing inline html tags, and other non-strictly markdown related uses",
+    help: "allow the use of the \"<thing>\" syntax, without raising an error when 'thing' is not a variable. Mostly useful when writing inline html tags, and other non-strictly markdown related uses",
 });
 //#endregion
 
 function main() {
-    // var server: refreshServer | undefined;
-    const clargs = argParser.parse_args();
+    let clargs, fileargs;
+    let server: WebSocketServer | undefined;
+
+    /* Read config file or parse args from cmd-line */
+    if (fs.existsSync(configFileName)) {
+        let data: { [key: string]: string | boolean | number } = JSON.parse(fs.readFileSync(configFileName)).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);
+    } else {
+        clargs = argParser.parse_args();
+    }
 
     /* helper method for calling parser */
     const compile = (source, output, cb?) => {
@@ -93,7 +119,10 @@ function main() {
 
         try {
             compile(clargs.src, clargs.output, () => {
-                // if (server.refresh) server.refresh();
+                /* after compile, send refresh command to clients */
+                server.clients.forEach((client) => {
+                    if (client.OPEN) client.send("refresh");
+                });
             });
         } catch (e) {
             console.log(e.message);
@@ -107,16 +136,16 @@ function main() {
         clargs.src = path.join(clargs.src, clargs.entry);
     }
 
-    const srcDirName = path.dirname(clargs.src);
-
     if (clargs.debug) console.dir(clargs);
 
+    /* compile once */
     if (!clargs.watch) compile(clargs.src, clargs.output);
 
+    /* watch the folder and recompile on change */
     if (clargs.watch) {
-        /* watch the folder of entry */
-        // server = wsServer();
+        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 {

package/src/commands.ts

@@ -1,36 +1,48 @@
 import * as path from "path";
-import { title } from "process";
 import Parser from "./parse";
+import * as fs from "fs";
+import templates, { new_template } from "./templates";
+import requireRuntime from "require-runtime";
+
+export class MDMError extends Error {
+    match: RegExpMatchArray;
+    constructor(message: string, match: RegExpMatchArray) {
+        super(message);
+        this.name = "MDMError";
+        this.match = match;
+    }
+}
 
-const commands = {
+export const commands: {
+    preparse: Command[];
+    parse: Command[];
+    postparse: Command[];
+} = {
     preparse: [],
     parse: [],
     postparse: [],
 };
 
-const CommandType = {
-    PREPARSE: 0,
-    PARSE: 1,
-    POSTPARSE: 2,
-};
+export enum CommandType {
+    PREPARSE,
+    PARSE,
+    POSTPARSE,
+}
 
-enum TargetType {
+export enum TargetType {
     HTML,
     MARKDOWN,
 }
 
-class Command {
-    type: number;
-    validator: (token: string, parser: Parser) => boolean | RegExpMatchArray;
-    acter: (token: string, parser: Parser) => string | void;
+export class Command {
+    validator: RegExp;
+    acter: (match: RegExpMatchArray, parser: Parser) => string | void;
+    type: CommandType;
 
     constructor(
-        type,
-        validator: (
-            token: string,
-            parser: Parser
-        ) => boolean | RegExpMatchArray,
-        acter: (token: string, parser: Parser) => string | void
+        validator: RegExp,
+        acter: (match: RegExpMatchArray, parser: Parser) => string | void,
+        type: CommandType,
     ) {
         this.type = type;
         this.validator = validator;
@@ -50,131 +62,191 @@ class Command {
         }
     }
 
-    valid(token, parser) {
-        return this.validator(token, parser);
-    }
-
-    act(token, parser) {
-        return this.acter(token, parser);
+    act(match, parser) {
+        return this.acter(match, parser);
     }
 }
 
 /* variable shorthand */
 new Command(
+    /(\s|^)<(.+)>/,
+    (match, parser) => `${match[1]}#mdvar<${match[2]}>`,
     CommandType.PREPARSE,
-    (t, p) => t.match(/(?:\s|^)<\w+>/),
-    (t, p) => `#mdvar` + t
 );
 
 /* mddef */
 new Command(
+    /#mddef< *(.+?) *= *(.+?) *>/ /* first .+ is lazy so as to not match following spaces */,
+    (match, parser) => {
+        parser.opts.defs[match[1]] = match[2].replace("_", " ");
+    },
     CommandType.PARSE,
-    (t, p) => t.match(/^#mddef<(\w+)=(\w+)>/),
-    (t, p) => {
-        const m = t.match(/^#mddef<(\w+)=(\w+)>/);
-        p.opts.defs[m[1]] = m[2];
-    }
 );
 
 /* mdvar */
 new Command(
-    CommandType.PARSE,
-    (t, p) => t.match(/^#mdvar<(\w+)>/) || t.match(/^<(\w+)>/),
-    (t, p) => {
-        const match = t.match(/#mdvar<(\w+)>/);
-        let value = p.opts.defs[match[1]];
-        if (!value && !p.opts.allow_undef)
+    /#mdvar<(.+?)>/,
+    (match, parser) => {
+        let value = parser.opts.defs[match[1]];
+        if (!value && !parser.opts.allow_undefined)
             throw new Error(`Undefined variable: ${match[1]}`);
-        value = value || `<${match[1]}>`;
-        return t.replace(match[0], value.replace("_", " "));
-    }
+        return (value = value || `<${match[1]}>`);
+    },
+    CommandType.PARSE,
 );
 
 /** mdinclude */
 new Command(
-    CommandType.PARSE,
-    (t, p) => t.match(/^#mdinclude<([\w.\/-]+)(?:[,\s]+([\w]+))?>/),
-    (t, p) => {
+    /#mdinclude<([\w.\/-]+)(?:[,\s]+([\w]+))?>/,
+    (match, parser) => {
         /* increase the current recursive depth */
-        p.opts.depth++;
+        parser.opts.depth++;
 
-        if (p.opts.depth > p.opts.max_depth) {
+        if (parser.opts.depth > parser.opts.max_depth) {
             throw new Error("max depth exceeded!");
         }
 
         /* get the matching group */
-        const match = t.match(/^#mdinclude<([\w.\/-]+)(?:[,\s]+([\w]+))?>/);
-
         const [_, name, condition] = match;
 
         /* implement conditional imports */
-        if (condition && !p.opts.args.includes(condition)) return;
+        if (condition && !parser.opts.args.includes(condition)) return;
 
-        const recursiveParser = new Parser(path.join(p.wd, name), p.opts, {
-            parent: p,
-        });
+        const recursiveParser = new Parser(
+            path.join(parser.wd, name),
+            parser.opts,
+            {
+                parent: parser,
+            },
+        );
 
         /* keep the options the same */
-        recursiveParser.opts = p.opts;
-        recursiveParser.parent = p;
+        recursiveParser.opts = parser.opts;
+        recursiveParser.parent = parser;
 
         const fileType = path.extname(recursiveParser.file);
 
         const blob =
             fileType === ".md"
-                ? recursiveParser.get(p.opts.targetType)
+                ? recursiveParser.get(parser.opts.targetType)
                 : recursiveParser.raw;
 
-        p.opts.depth--;
+        parser.opts.depth--;
         return blob;
-    }
+    },
+    CommandType.PARSE,
 );
 
+/* mdlabel */
 new Command(
-    CommandType.PREPARSE,
-    (t, p) => t.match(/#mdlabel<(\d+),([\w\W]+)>/),
-    (t, p) => {
-        if (p.opts.targetType !== TargetType.HTML) return;
+    /#mdlabel<(\d+),\s?(.+)>/,
+    (match, parser) => {
+        if (parser.opts.targetType !== TargetType.HTML) return "";
 
-        const match = t.match(/#mdlabel<([\d]+),([\w\W]+)>/);
         const level = Number.parseInt(match[1]);
         const title = match[2];
-        const link = p.titleId(title);
-        p.opts.secs.push({ level, title });
+        const link = parser.titleId(title);
+        parser.opts.secs.push({ level, title });
         return `<span id="${link}"></span>`;
-    }
+    },
+    CommandType.PREPARSE,
 );
 
+/* mdref */
 new Command(
-    CommandType.PARSE,
-    (t, p) => t.match(/#mdref<([\w\W]+)>/),
-
-    (t, p) => {
-        const match = t.match(/#mdref<([\w\W]+)>/);
+    /#mdref<(.+)>/,
 
-        for (let i = 0; i < p.opts.secs.length; i++) {
-            let { title } = p.opts.secs[i];
+    (match, parser) => {
+        for (let i = 0; i < parser.opts.secs.length; i++) {
+            let { title } = parser.opts.secs[i];
             if (title === match[1]) break;
 
-            if (i === p.opts.secs.length - 1)
+            if (i === parser.opts.secs.length - 1)
                 throw new Error(
-                    `Reference to [${match[1]}] could not be resolved!`
+                    `Reference to [${match[1]}] could not be resolved!`,
                 );
         }
 
         match[1] = match[1].replace("_", " ");
-        const link = p.titleId(match[1]);
-        if (p.opts.targetType === TargetType.HTML)
+        const link = parser.titleId(match[1]);
+        if (parser.opts.targetType === TargetType.HTML)
             return `<a href="#${link}">${match[1]}</a>`;
-        else if (p.opts.targetType === TargetType.MARKDOWN)
+        else if (parser.opts.targetType === TargetType.MARKDOWN)
             return `[${match[1]}](#${link})`;
-    }
+    },
+    CommandType.PARSE,
+);
+
+/* mdtemplate */
+new Command(
+    /#mdtemplate<([\w\W]+)>/,
+    (match, parser) => {
+        const template = match[1];
+        const replacement = templates[template];
+
+        if (replacement !== undefined) {
+            return replacement;
+        } else {
+            throw new MDMError(`Template \"${template}\" not found!`, match);
+        }
+    },
+    CommandType.PARSE,
 );
 
 new Command(
+    /#mdmaketoc(?:<>)?/,
+    (match, parser) => parser.gen_toc(),
     CommandType.POSTPARSE,
-    (t, p) => t.match(/#mdmaketoc/),
-    (t, p) => p.gen_toc()
 );
 
-module.exports = commands;
+export function load_extensions(parser: Parser) {
+    /* global extention */
+    const global_extensions_path = path.join(process.cwd(), "extensions.js");
+    if (fs.existsSync(global_extensions_path)) {
+        const extensions = requireRuntime(global_extensions_path);
+        extensions.main(new_template, new_command);
+
+        if (parser.opts.verbose)
+            console.log(
+                `Loaded global extensions from ${global_extensions_path}`
+                    .yellow,
+            );
+    } else if (parser.opts.debug) {
+        console.log(
+            `No global extensions found at ${global_extensions_path}`.red,
+        );
+    }
+
+    /* project extention */
+    const project_extensions_path = path.join(parser.wd_full, "extensions.js");
+    if (fs.existsSync(project_extensions_path)) {
+        const extensions = requireRuntime(project_extensions_path);
+        extensions.main(new_template, new_command);
+
+        if (parser.opts.verbose)
+            console.log(
+                `Loaded project extensions from ${project_extensions_path}`
+                    .yellow,
+            );
+    } else if (parser.opts.debug) {
+        console.log(
+            `No project extensions found at ${project_extensions_path}!`.red,
+        );
+    }
+}
+
+/**
+ *
+ * @param regex The regex to match the command
+ * @param acter The function called when a match is found. Takes two arguments, `match` and `parser`. `match` is the result of the regex match, and `parser` is the parser instance. The function should return the replacement string.
+ * @param type When the command should be run. Can be `CommandType.PREPARSE`, `CommandType.PARSE`, or `CommandType.POSTPARSE`. Defaults to `CommandType.PARSE`.
+ */
+export function new_command(
+    regex: RegExp,
+    acter: (match: RegExpMatchArray, parser: Parser) => string,
+    type?: CommandType,
+) {
+    new Command(regex, acter, type || CommandType.PARSE);
+}
+
+export default { commands, load_extensions };