@mryhryki/markdown-preview 0.5.4 → 0.5.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mryhryki/markdown-preview",
   "description": "Markdown realtime preview on browser",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "author": "mryhryki",
   "license": "MIT",
   "publishConfig": {

package/src/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const express_ws_1 = __importDefault(require("express-ws"));
+const serve_index_1 = __importDefault(require("serve-index"));
+const opener_1 = __importDefault(require("opener"));
+const logger_1 = require("./lib/logger");
+const show_1 = require("./lib/show");
+const markdown_1 = require("./markdown");
+const websocket_1 = require("./websocket");
+const directory_1 = require("./lib/directory");
+const params_1 = require("./lib/params");
+try {
+    const params = new params_1.Params(process.env, process.argv.slice(2));
+    if (params.help)
+        (0, show_1.showUsage)();
+    if (params.version)
+        (0, show_1.showVersion)();
+    const logger = (0, logger_1.getLogger)(params.logLevel);
+    const previewUrl = `http://localhost:${params.port}`;
+    console.log("Root Directory :", directory_1.rootDir);
+    console.log("Default File   :", params.filepath);
+    console.log("Extensions     :", params.extensions.join(", "));
+    console.log("Template File  :", params.template);
+    console.log(`Preview URL    : ${previewUrl}`);
+    const app = (0, express_1.default)();
+    (0, express_ws_1.default)(app);
+    app.get("/", (_req, res) => res.redirect(params.filepath));
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    app.ws("/ws", (0, websocket_1.WebSocketHandler)(logger));
+    params.extensions.forEach((ext) => {
+        app.get(new RegExp(`^/.+\.${ext}$`), (0, markdown_1.MarkdownHandler)(params.template));
+    });
+    app.use(express_1.default.static(directory_1.rootDir, { index: false }));
+    app.use(express_1.default.static(directory_1.staticDir, { index: false }));
+    app.use((0, serve_index_1.default)(directory_1.rootDir, { icons: true, view: "details" }));
+    app.listen(params.port);
+    if (!params.noOpener) {
+        (0, opener_1.default)(previewUrl);
+    }
+}
+catch (err) {
+    console.error(err);
+    (0, show_1.showUsage)(true);
+}

package/src/lib/directory.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateDir = exports.staticDir = exports.projectDir = exports.rootDir = void 0;
+const path_1 = __importDefault(require("path"));
+exports.rootDir = process.cwd();
+exports.projectDir = path_1.default.resolve(__dirname, "..", "..");
+exports.staticDir = path_1.default.resolve(exports.projectDir, "static");
+exports.templateDir = path_1.default.resolve(exports.projectDir, "template");

package/src/lib/file.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.existsFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+function existsFile(filepath) {
+    try {
+        fs_1.default.statSync(filepath);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+exports.existsFile = existsFile;

package/src/lib/file_watcher.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWatcher = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const directory_1 = require("./directory");
+class FileWatcher {
+    constructor(logger) {
+        this.logger = logger;
+        this._target = {};
+        setInterval(() => {
+            Object.keys(this._target).forEach((filepath) => {
+                try {
+                    const fileinfo = this._target[filepath];
+                    const currentLastModified = this.getFileLastModified(filepath);
+                    if (fileinfo.lastModified !== currentLastModified) {
+                        this.logger.info("File update:", path_1.default.resolve(directory_1.rootDir, filepath));
+                        fileinfo.lastModified = currentLastModified;
+                        if (this._onFileChanged != null) {
+                            this._onFileChanged(this.getFileInfo(filepath));
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            });
+        }, 250 /* check 4 times per second */);
+    }
+    onFileChanged(callback) {
+        this._onFileChanged = callback;
+    }
+    addTargetFile(filepath) {
+        if (this._target[filepath] != null)
+            return;
+        this.logger.debug("Add watch target:", filepath);
+        this._target[filepath] = {
+            lastModified: this.getFileLastModified(filepath),
+        };
+    }
+    removeTargetFile(filepath) {
+        if (this._target[filepath] == null)
+            return;
+        this.logger.debug("Remove watch target:", filepath);
+        delete this._target[filepath];
+    }
+    getFileLastModified(filepath) {
+        return fs_1.default.statSync(path_1.default.resolve(directory_1.rootDir, filepath)).mtimeMs;
+    }
+    getFileInfo(filepath) {
+        const absolutePath = path_1.default.resolve(directory_1.rootDir, filepath);
+        const markdown = fs_1.default.readFileSync(absolutePath, "utf-8");
+        return { filepath, markdown };
+    }
+}
+exports.FileWatcher = FileWatcher;

package/src/lib/logger.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = exports.getLogLevel = void 0;
+const log4js_1 = __importDefault(require("log4js"));
+const LogLevels = ["trace", "debug", "info", "warn", "error", "fatal"];
+function getLogLevel(level) {
+    switch (level) {
+        case "trace":
+        case "debug":
+        case "info":
+        case "warn":
+        case "error":
+        case "fatal":
+            return level;
+        default:
+            throw new Error(`Undefined log level: ${level}`);
+    }
+}
+exports.getLogLevel = getLogLevel;
+function getLogger(logLevel) {
+    log4js_1.default.configure({
+        appenders: {
+            console: {
+                type: "console",
+                layout: {
+                    type: "basic",
+                },
+            },
+        },
+        categories: {
+            default: {
+                appenders: ["console"],
+                level: logLevel,
+            },
+        },
+    });
+    return log4js_1.default.getLogger();
+}
+exports.getLogger = getLogger;

package/src/lib/params.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Params = void 0;
+const path_1 = __importDefault(require("path"));
+const directory_1 = require("./directory");
+const file_1 = require("./file");
+const logger_1 = require("./logger");
+class Params {
+    constructor(env, argv) {
+        const obj = Object.assign(this.getDefaultParams(), this.parseEnv(env), this.parseArgv(argv));
+        this._params = {
+            filepath: this.checkFilepath(obj.filepath),
+            extensions: obj.extensions,
+            template: this.checkTemplate(obj.template),
+            port: this.checkPort(obj.port),
+            logLevel: (0, logger_1.getLogLevel)(obj.logLevel),
+            noOpener: obj.noOpener,
+            version: obj.version,
+            help: obj.help,
+        };
+    }
+    getDefaultParams() {
+        return {
+            filepath: "README.md",
+            extensions: ["md", "markdown"],
+            template: "default",
+            port: 34567,
+            logLevel: "info",
+            noOpener: false,
+            version: false,
+            help: false,
+        };
+    }
+    parseEnv(env) {
+        const params = {};
+        if (env.MARKDOWN_PREVIEW_FILE) {
+            params.filepath = env.MARKDOWN_PREVIEW_FILE;
+        }
+        if (env.MARKDOWN_PREVIEW_EXTENSIONS) {
+            params.extensions = this.checkExtensions(env.MARKDOWN_PREVIEW_EXTENSIONS);
+        }
+        if (env.MARKDOWN_PREVIEW_TEMPLATE) {
+            params.template = env.MARKDOWN_PREVIEW_TEMPLATE;
+        }
+        if (env.MARKDOWN_PREVIEW_PORT) {
+            params.port = parseInt(env.MARKDOWN_PREVIEW_PORT, 10);
+        }
+        if (env.MARKDOWN_PREVIEW_NO_OPENER) {
+            params.noOpener = env.MARKDOWN_PREVIEW_NO_OPENER === "true";
+        }
+        if (env.MARKDOWN_PREVIEW_LOG_LEVEL) {
+            params.logLevel = (0, logger_1.getLogLevel)(env.MARKDOWN_PREVIEW_LOG_LEVEL);
+        }
+        return params;
+    }
+    parseArgv(argv) {
+        const params = {};
+        for (let i = 0; i < argv.length; i++) {
+            switch (argv[i]) {
+                case "-f":
+                case "--file":
+                    params.filepath = argv[i + 1];
+                    i++;
+                    break;
+                case "-e":
+                case "--extensions":
+                    params.extensions = this.checkExtensions(argv[i + 1]);
+                    i++;
+                    break;
+                case "-t":
+                case "--template":
+                    params.template = argv[i + 1];
+                    i++;
+                    break;
+                case "-p":
+                case "--port":
+                    params.port = parseInt(argv[i + 1], 10);
+                    i++;
+                    break;
+                case "-l":
+                case "--log-level":
+                    params.logLevel = (0, logger_1.getLogLevel)(argv[i + 1]);
+                    i++;
+                    break;
+                case "--no-opener":
+                    params.noOpener = true;
+                    break;
+                case "-v":
+                case "--version":
+                    params.version = true;
+                    break;
+                case "-h":
+                case "--help":
+                    params.help = true;
+                    break;
+                default:
+                    throw new Error(`Unknown option: ${argv[i]}`);
+            }
+        }
+        return params;
+    }
+    checkFilepath(filepath) {
+        if (path_1.default.isAbsolute(filepath)) {
+            throw new Error(`Absolute path is prohibited: ${filepath}`);
+        }
+        if (!(0, file_1.existsFile)(filepath)) {
+            throw new Error(`File not found: ${filepath}`);
+        }
+        if (path_1.default.relative(directory_1.rootDir, filepath).match(/\.\./) != null) {
+            throw new Error(`Illegal file path: ${filepath}`);
+        }
+        return filepath;
+    }
+    checkExtensions(extensions) {
+        const extensionList = extensions.split(",").map((ext) => ext.trim());
+        if (extensionList.length === 0) {
+            throw new Error(`Extensions is empty: ${extensions}`);
+        }
+        return extensionList;
+    }
+    checkTemplate(template) {
+        if ((0, file_1.existsFile)(path_1.default.resolve(directory_1.templateDir, `${template}.html`))) {
+            return path_1.default.resolve(directory_1.templateDir, `${template}.html`);
+        }
+        else if ((0, file_1.existsFile)(path_1.default.resolve(directory_1.rootDir, template))) {
+            return path_1.default.resolve(directory_1.rootDir, template);
+        }
+        throw new Error(`Template file not found: ${template}`);
+    }
+    checkPort(port) {
+        if (!isNaN(port) && 0 < port && port <= 65535) {
+            return port;
+        }
+        throw new Error(`Invalid port: ${port}`);
+    }
+    get filepath() {
+        return this._params.filepath;
+    }
+    get extensions() {
+        return this._params.extensions;
+    }
+    get template() {
+        return this._params.template;
+    }
+    get port() {
+        return this._params.port;
+    }
+    get logLevel() {
+        return this._params.logLevel;
+    }
+    get noOpener() {
+        return this._params.noOpener;
+    }
+    get version() {
+        return this._params.version;
+    }
+    get help() {
+        return this._params.help;
+    }
+}
+exports.Params = Params;

package/src/lib/params.test.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const directory_1 = require("./directory");
+const params_1 = require("./params");
+const DEFAULT_VALUES = {
+    filepath: "README.md",
+    extensions: ["md", "markdown"],
+    template: path_1.default.resolve(directory_1.projectDir, "template/default.html"),
+    port: 34567,
+    logLevel: "info",
+    noOpener: false,
+    version: false,
+    help: false,
+};
+describe("Params", () => {
+    it("not specify", () => {
+        const params = new params_1.Params({}, []);
+        expect(params._params).toEqual(DEFAULT_VALUES);
+    });
+    it("specify all short argument", () => {
+        const argv = [
+            "-f",
+            "test/markdown/markdown1.md",
+            "-e",
+            "ext1,ext2",
+            "-t",
+            "test/template/template1.html",
+            "-p",
+            "100",
+            "-v",
+            "-h",
+        ];
+        const expectParams = {
+            filepath: "test/markdown/markdown1.md",
+            extensions: ["ext1", "ext2"],
+            template: path_1.default.resolve(directory_1.projectDir, "test/template/template1.html"),
+            port: 100,
+            logLevel: "info",
+            noOpener: false,
+            version: true,
+            help: true,
+        };
+        const params = new params_1.Params({}, argv);
+        expect(params._params).toEqual(expectParams);
+    });
+    it("specify all long argument", () => {
+        const argv = [
+            "--file",
+            "test/markdown/markdown1.md",
+            "--extensions",
+            "ext1,ext2",
+            "--template",
+            "test/template/template1.html",
+            "--port",
+            "100",
+            "--log-level",
+            "trace",
+            "--no-opener",
+            "--version",
+            "--help",
+        ];
+        const expectParams = {
+            filepath: "test/markdown/markdown1.md",
+            extensions: ["ext1", "ext2"],
+            template: path_1.default.resolve(directory_1.projectDir, "test/template/template1.html"),
+            port: 100,
+            logLevel: "trace",
+            noOpener: true,
+            version: true,
+            help: true,
+        };
+        const params = new params_1.Params({}, argv);
+        expect(params._params).toEqual(expectParams);
+    });
+    it("specify all environment variable", () => {
+        const env = {
+            MARKDOWN_PREVIEW_FILE: "test/markdown/markdown1.md",
+            MARKDOWN_PREVIEW_EXTENSIONS: "ext1, ext2",
+            MARKDOWN_PREVIEW_TEMPLATE: "test/template/template1.html",
+            MARKDOWN_PREVIEW_PORT: "100",
+            MARKDOWN_PREVIEW_LOG_LEVEL: "trace",
+            MARKDOWN_PREVIEW_NO_OPENER: "true",
+        };
+        const expectParams = {
+            filepath: "test/markdown/markdown1.md",
+            extensions: ["ext1", "ext2"],
+            template: path_1.default.resolve(directory_1.projectDir, "test/template/template1.html"),
+            port: 100,
+            logLevel: "trace",
+            noOpener: true,
+            version: false,
+            help: false,
+        };
+        const params = new params_1.Params(env, []);
+        expect(params._params).toEqual(expectParams);
+    });
+});

package/src/lib/show.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showVersion = exports.showUsage = void 0;
+const pkg = __importStar(require("../../package.json"));
+function showUsage(error = false) {
+    const usage = `
+Usage:
+  npx @mryhryki/markdown-preview [options]
+  markdown-preview [options]
+
+Options:
+  -f,--file     [relative_file_path] Default: README.md
+  -t,--template [template_name]      Default: default
+  -p,--port     [port_number]        Default: 34567
+  -v,--version
+  -h,--help
+`;
+    console.log(usage);
+    process.exit(error ? 1 : 0);
+}
+exports.showUsage = showUsage;
+function showVersion() {
+    console.log(pkg.version);
+    process.exit(0);
+}
+exports.showVersion = showVersion;

package/src/lib/socket_manager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketManager = void 0;
+class SocketManager {
+    constructor() {
+        this._sockets = [];
+    }
+    addSocket(socket, filepath) {
+        this._sockets.push({ socket, filepath });
+    }
+    removeSocket(socket) {
+        this._sockets = this._sockets.filter(({ socket: s }) => s !== socket);
+    }
+    getSockets(filepath) {
+        return this._sockets.filter(({ filepath: fp }) => fp === filepath).map((s) => s.socket);
+    }
+    countSocket(filepath = null) {
+        if (filepath == null) {
+            return this._sockets.length;
+        }
+        return this.getSockets(filepath).length;
+    }
+}
+exports.SocketManager = SocketManager;

package/src/lib/socket_manager.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const socket_manager_1 = require("./socket_manager");
+const dummySocket1 = { name: "socket1" }; // eslint-disable-line @typescript-eslint/no-explicit-any
+const dummySocket2 = { name: "socket2" }; // eslint-disable-line @typescript-eslint/no-explicit-any
+const dummySocket3 = { name: "socket3" }; // eslint-disable-line @typescript-eslint/no-explicit-any
+const dummyFilepath1 = "file1";
+const dummyFilepath2 = "file2";
+const dummyInfo1 = { socket: dummySocket1, filepath: dummyFilepath1 };
+const dummyInfo2 = { socket: dummySocket2, filepath: dummyFilepath2 };
+const dummyInfo3 = { socket: dummySocket3, filepath: dummyFilepath2 };
+describe("SocketManager", () => {
+    it("works normally", () => {
+        const socketManager = new socket_manager_1.SocketManager();
+        expect(socketManager._sockets).toEqual([]);
+        socketManager.addSocket(dummySocket1, dummyFilepath1);
+        expect(socketManager._sockets).toEqual([dummyInfo1]);
+        socketManager.addSocket(dummySocket2, dummyFilepath2);
+        expect(socketManager._sockets).toEqual([dummyInfo1, dummyInfo2]);
+        socketManager.addSocket(dummySocket3, dummyFilepath2);
+        expect(socketManager._sockets).toEqual([dummyInfo1, dummyInfo2, dummyInfo3]);
+        expect(socketManager.getSockets(dummyFilepath1)).toEqual([dummySocket1]);
+        expect(socketManager.getSockets(dummyFilepath2)).toEqual([dummySocket2, dummySocket3]);
+        expect(socketManager.countSocket()).toEqual(3);
+        expect(socketManager.countSocket(dummyFilepath1)).toEqual(1);
+        expect(socketManager.countSocket(dummyFilepath2)).toEqual(2);
+        socketManager.removeSocket(dummySocket2);
+        expect(socketManager._sockets).toEqual([dummyInfo1, dummyInfo3]);
+        socketManager.removeSocket(dummySocket1);
+        expect(socketManager._sockets).toEqual([dummyInfo3]);
+        socketManager.removeSocket(dummySocket3);
+        expect(socketManager._sockets).toEqual([]);
+    });
+});

package/src/markdown.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownHandler = void 0;
+const path_1 = __importDefault(require("path"));
+const directory_1 = require("./lib/directory");
+const file_1 = require("./lib/file");
+function MarkdownHandler(template) {
+    return (req, res, next) => {
+        const filepath = path_1.default.resolve(directory_1.rootDir, decodeURIComponent(req.path.substr(1)));
+        if ((0, file_1.existsFile)(filepath)) {
+            res.sendFile(template);
+        }
+        else {
+            next();
+        }
+    };
+}
+exports.MarkdownHandler = MarkdownHandler;

package/src/websocket.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandler = void 0;
+const path_1 = __importDefault(require("path"));
+const file_watcher_1 = require("./lib/file_watcher");
+const socket_manager_1 = require("./lib/socket_manager");
+const directory_1 = require("./lib/directory");
+function WebSocketHandler(logger) {
+    let socketSeqNo = 1;
+    const socketManager = new socket_manager_1.SocketManager();
+    const fileWatcher = new file_watcher_1.FileWatcher(logger);
+    fileWatcher.onFileChanged((fileinfo) => {
+        socketManager.getSockets(fileinfo.filepath).forEach((ws) => {
+            ws.send(JSON.stringify(fileinfo));
+        });
+    });
+    return (ws, req) => {
+        const wsSeqNo = socketSeqNo++;
+        try {
+            logger.debug("WebSocket connected:", wsSeqNo);
+            const pathInQuery = typeof req.query.path === "string" ? req.query.path : "";
+            const filepath = path_1.default.resolve(directory_1.rootDir, decodeURIComponent(pathInQuery.substring(1)));
+            fileWatcher.addTargetFile(filepath);
+            socketManager.addSocket(ws, filepath);
+            ws.on("close", () => {
+                logger.debug("WebSocket close:", wsSeqNo);
+                socketManager.removeSocket(ws);
+                if (socketManager.countSocket(filepath) === 0) {
+                    fileWatcher.removeTargetFile(filepath);
+                }
+            });
+            ws.send(JSON.stringify(fileWatcher.getFileInfo(filepath)));
+        }
+        catch (e) {
+            logger.error(e);
+        }
+    };
+}
+exports.WebSocketHandler = WebSocketHandler;