vuepress-jsdoc 4.3.1 → 6.1.0

package/dist/index.js

@@ -1,81 +1,3 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generate = void 0;
 /*
  * @vuepress
  * ---
@@ -83,309 +5,244 @@ exports.generate = void 0;
  * headline: The Main File
  * ---
  */
-var chalk_1 = __importDefault(require("chalk"));
-var chokidar_1 = __importDefault(require("chokidar"));
-var del_1 = __importDefault(require("del"));
-var promises_1 = __importDefault(require("fs/promises"));
-var mkdirp_1 = __importDefault(require("mkdirp"));
-var readline_1 = __importDefault(require("readline"));
-var constants_1 = require("./constants");
-var list_folder_1 = require("./lib/list-folder");
-var parser_1 = require("./lib/parser");
-var vue_sidebar_1 = require("./lib/vue-sidebar");
+import chokidar from 'chokidar';
+import { deleteAsync } from 'del';
+import kleur from 'kleur';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { StatisticType } from './constants.js';
+import { getPageName, listFolder, normalizePath } from './lib/list-folder.js';
+import { getDestFolder, parseFile, writeContentToFile } from './lib/parser.js';
+import { createSidebarConfig } from './lib/vue-sidebar.js';
+export { listFolder } from './lib/list-folder.js';
+export { parseFile, writeContentToFile } from './lib/parser.js';
+export { createSidebarConfig, generateVitepressSidebar, generateVueSidebar } from './lib/vue-sidebar.js';
+export { parseComment, parseVuepressFileHeader } from './lib/comment-parser.js';
+export { defineConfig, loadConfig } from './lib/config.js';
+export { vuepressJsdocPlugin } from './lib/vuepress-plugin.js';
+export { StatisticType } from './constants.js';
 /**
- * Create the sidebar
- * @param {object} options
- * @returns {Promise}
+ * Split a comma separated string or a list of strings into a list
+ * @param {string|string[]} value
+ * @returns {string[]}
  */
-var createVuepressSidebar = function (options) {
-    return promises_1.default.writeFile("".concat(options.docsFolder, "/config.js"), "exports.fileTree=".concat(JSON.stringify(options.fileTree), ";exports.sidebarTree = (title = 'Mainpage') => (").concat(JSON.stringify((0, vue_sidebar_1.generateVueSidebar)(options)).replace('::vuepress-jsdoc-title::', '"+title+"'), ");"));
-};
+const toList = (value) => (Array.isArray(value) ? value : (value || '').split(','))
+    .flatMap((v) => v.split(','))
+    .map((v) => v.trim())
+    .filter(Boolean);
 /**
- * Parse file
- * @param {DirectoryFile} file
+ * Parse all CLI arguments
  * @param {CLIArguments} argv
- * @returns {Promise}
+ * @returns {object} all arguments
  */
-var parseDirectoryFile = function (file, argv) {
-    var _a = parseArguments(argv), srcFolder = _a.srcFolder, docsFolder = _a.docsFolder, partials = _a.partials;
-    if (!file.isDir && file.folder) {
-        if (['.jsx', '.tsx', '.ts', '.js'].includes(file.ext || '')) {
-            return (0, parser_1.parseFile)(file, srcFolder, docsFolder, argv.jsDocConfigPath, partials);
-        }
-        if (file.ext === '.vue') {
-            return (0, parser_1.parseVueFile)(file, srcFolder, docsFolder);
-        }
-    }
+export const parseArguments = (argv) => {
+    const codeFolder = normalizePath(argv.folder || 'code');
+    const dist = normalizePath(argv.dist || './documentation');
+    const srcFolder = normalizePath(argv.source || './src');
+    return {
+        include: toList(argv.include),
+        exclude: toList(argv.exclude),
+        srcFolder,
+        codeFolder,
+        docsFolder: path.posix.join(dist, codeFolder),
+        title: argv.title || 'API',
+        readme: argv.readme,
+        readmePath: argv.readme || path.join(srcFolder, 'README.md'),
+        rmPattern: toList(argv.rmPattern),
+        partials: toList(argv.partials),
+        jsDocConfigPath: argv.jsDocConfigPath,
+        collapsible: Boolean(argv.collapsible),
+        format: argv.format === 'vitepress' ? 'vitepress' : 'vuepress'
+    };
 };
 /**
- * Create the readme file. First page when entering the documentation.
- * @param {CLIArguments} argv
- * @param {string} deletedPaths
- * @returns {void}
+ * Run async tasks with a limited concurrency, because every jsdoc call spawns a child process.
+ * @param {T[]} items
+ * @param {Function} fn
+ * @returns {Promise<R[]>} results in the order of the items
  */
-var createReadmeFile = function (argv, deletedPaths) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, srcFolder, codeFolder, docsFolder, title, readme, readMeContent, readmePath, e_1;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                _a = parseArguments(argv), srcFolder = _a.srcFolder, codeFolder = _a.codeFolder, docsFolder = _a.docsFolder, title = _a.title, readme = _a.readme;
-                readMeContent = "### Welcome to ".concat(title);
-                readmePath = readme || "".concat(srcFolder, "/README.md");
-                _b.label = 1;
-            case 1:
-                _b.trys.push([1, 3, , 4]);
-                return [4 /*yield*/, promises_1.default.readFile(readmePath, 'utf-8')];
-            case 2:
-                readMeContent = _b.sent();
-                if (deletedPaths === null || deletedPaths === void 0 ? void 0 : deletedPaths.some(function (p) { return p.indexOf("".concat(codeFolder, "/README.md")) !== -1; })) {
-                    console.log("\n".concat(chalk_1.default.white.bgBlack(' README '), " ").concat(chalk_1.default.dim(readmePath.replace('README.md', ''))).concat(chalk_1.default.bold('README.md'), " \u2192  ").concat(chalk_1.default.dim(docsFolder)).concat(chalk_1.default.bold('/README.md')));
-                }
-                return [3 /*break*/, 4];
-            case 3:
-                e_1 = _b.sent();
-                console.log("\n".concat(chalk_1.default.white.bgBlack(' README '), " Add default README.md"));
-                return [3 /*break*/, 4];
-            case 4: return [4 /*yield*/, promises_1.default.writeFile("".concat(docsFolder, "/README.md"), readMeContent)];
-            case 5:
-                _b.sent();
-                return [2 /*return*/];
+const mapLimit = async (items, fn, limit = os.availableParallelism()) => {
+    const results = new Array(items.length);
+    let index = 0;
+    const worker = async () => {
+        while (index < items.length) {
+            const i = index++;
+            results[i] = await fn(items[i]);
         }
-    });
-}); };
+    };
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+    return results;
+};
 /**
- * Parse all CLI arguments
- * @param {CLIArguments} argv
- * @returns {object} all arguments
+ * Get the sidebar options of the given file tree
+ * @param {Options} options
+ * @param {FileTree[]} fileTree created by `listFolder`
+ * @returns {SidebarOptions}
  */
-var parseArguments = function (argv) {
-    return {
-        include: (argv.include || '').split(',').filter(Boolean),
-        exclude: (argv.exclude || '').split(',').filter(Boolean),
-        srcFolder: argv.source.replace('./', ''),
-        codeFolder: argv.folder,
-        docsFolder: "".concat(argv.dist, "/").concat(argv.folder),
-        title: argv.title,
-        readme: argv.readme,
-        rmPattern: argv.rmPattern || [],
-        partials: argv.partials || []
+export const getSidebarOptions = (options, fileTree) => ({
+    fileTree,
+    srcFolder: options.srcFolder,
+    docsFolder: options.docsFolder,
+    codeFolder: options.codeFolder,
+    title: options.title,
+    format: options.format,
+    collapsible: options.collapsible
+});
+/**
+ * Write the config.js with the file tree and sidebar
+ * @param {Options} options
+ * @param {FileTree[]} fileTree created by `listFolder`
+ * @returns {Promise<void>}
+ */
+const createVuepressSidebar = (options, fileTree) => fs.writeFile(path.join(options.docsFolder, 'config.js'), createSidebarConfig(getSidebarOptions(options, fileTree)));
+/**
+ * Parse a file and write the markdown file
+ * @param {DirectoryFile} file
+ * @param {Options} options
+ * @returns {Promise<ParseReturn>}
+ */
+const processFile = async (file, options) => {
+    const parseOptions = {
+        srcFolder: options.srcFolder,
+        destFolder: options.docsFolder,
+        jsDocConfigPath: options.jsDocConfigPath,
+        partials: options.partials
     };
+    const result = await parseFile(file, parseOptions);
+    await writeContentToFile(result);
+    return result;
 };
 /**
- * Default command that generate md files
- * @param {object} argv passed arguments
+ * Create the readme file. First page when entering the documentation.
+ * @param {Options} options
+ * @returns {Promise<void>}
  */
-var generate = function (argv) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, exclude, include, srcFolder, codeFolder, docsFolder, title, rmPattern, startTime, deletedPaths, lsFolder, parsePromises, _b, _c, file, e_2_1, _loop_1, _d, _e, file, result, _f, _g, file, _h, _j, entry, color, resultTime;
-    var e_2, _k, e_3, _l, e_4, _m, e_5, _o, _p;
-    return __generator(this, function (_q) {
-        switch (_q.label) {
-            case 0:
-                _a = parseArguments(argv), exclude = _a.exclude, include = _a.include, srcFolder = _a.srcFolder, codeFolder = _a.codeFolder, docsFolder = _a.docsFolder, title = _a.title, rmPattern = _a.rmPattern;
-                startTime = +new Date();
-                return [4 /*yield*/, (0, del_1.default)(__spreadArray(["".concat(docsFolder, "/**/*")], __read(rmPattern), false))];
-            case 1:
-                deletedPaths = _q.sent();
-                return [4 /*yield*/, (0, list_folder_1.listFolder)(srcFolder, exclude, include)];
-            case 2:
-                lsFolder = _q.sent();
-                return [4 /*yield*/, (0, mkdirp_1.default)(docsFolder)];
-            case 3:
-                _q.sent();
-                parsePromises = [];
-                _q.label = 4;
-            case 4:
-                _q.trys.push([4, 9, 10, 11]);
-                _b = __values(lsFolder.paths), _c = _b.next();
-                _q.label = 5;
-            case 5:
-                if (!!_c.done) return [3 /*break*/, 8];
-                file = _c.value;
-                if (!!file.isDir) return [3 /*break*/, 7];
-                readline_1.default.clearLine(process.stdout, 0);
-                readline_1.default.cursorTo(process.stdout, 0);
-                process.stdout.write(chalk_1.default.dim(" ".concat(file.path, " ")));
-                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 20); })];
-            case 6:
-                _q.sent();
-                _q.label = 7;
-            case 7:
-                _c = _b.next();
-                return [3 /*break*/, 5];
-            case 8: return [3 /*break*/, 11];
-            case 9:
-                e_2_1 = _q.sent();
-                e_2 = { error: e_2_1 };
-                return [3 /*break*/, 11];
-            case 10:
-                try {
-                    if (_c && !_c.done && (_k = _b.return)) _k.call(_b);
-                }
-                finally { if (e_2) throw e_2.error; }
-                return [7 /*endfinally*/];
-            case 11:
-                readline_1.default.clearLine(process.stdout, 0);
-                readline_1.default.cursorTo(process.stdout, 0);
-                _loop_1 = function (file) {
-                    parsePromises.push((function () { return __awaiter(void 0, void 0, void 0, function () {
-                        var data;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, parseDirectoryFile(file, argv)];
-                                case 1:
-                                    data = _a.sent();
-                                    if (data && (data === null || data === void 0 ? void 0 : data.relativePathDest)) {
-                                        return [2 /*return*/, (0, parser_1.writeContentToFile)(data, data.relativePathDest)];
-                                    }
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); })());
-                };
-                try {
-                    // iterate through files and parse them
-                    for (_d = __values(lsFolder.paths), _e = _d.next(); !_e.done; _e = _d.next()) {
-                        file = _e.value;
-                        _loop_1(file);
-                    }
-                }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
-                    try {
-                        if (_e && !_e.done && (_l = _d.return)) _l.call(_d);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                }
-                return [4 /*yield*/, Promise.all(parsePromises)];
-            case 12:
-                result = _q.sent();
-                result = result.filter(Boolean);
-                // write vuepress sidebar
-                return [4 /*yield*/, createVuepressSidebar({
-                        fileTree: lsFolder.tree,
-                        srcFolder: srcFolder,
-                        docsFolder: docsFolder,
-                        codeFolder: codeFolder,
-                        title: title
-                    })];
-            case 13:
-                // write vuepress sidebar
-                _q.sent();
-                try {
-                    // print stats
-                    for (_f = __values(lsFolder.excluded), _g = _f.next(); !_g.done; _g = _f.next()) {
-                        file = _g.value;
-                        console.log(chalk_1.default.reset.inverse.bold.blue(' EXCLUDE '), "".concat(chalk_1.default.dim(file.folder)).concat(chalk_1.default.bold(file.name + file.ext)));
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (_g && !_g.done && (_m = _f.return)) _m.call(_f);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
-                console.log();
-                try {
-                    for (_h = __values(result.flat()), _j = _h.next(); !_j.done; _j = _h.next()) {
-                        entry = _j.value;
-                        if (!entry.file)
-                            continue;
-                        color = (_p = {},
-                            _p[constants_1.StatisticType.INCLUDE] = 'green',
-                            _p[constants_1.StatisticType.ERROR] = 'red',
-                            _p[constants_1.StatisticType.EMPTY] = 'yellow',
-                            _p[constants_1.StatisticType.EXCLUDE] = 'blue',
-                            _p)[entry.type];
-                        console.log(chalk_1.default.reset.inverse.bold[color](" ".concat(entry.type, " ")), "".concat(chalk_1.default.dim(entry.relativePathSrc)).concat(chalk_1.default.bold(entry.file.name + entry.file.ext), " \u2192 ").concat(chalk_1.default.dim(entry.relativePathDest)).concat(chalk_1.default.bold(entry.file.name + '.md')));
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (_j && !_j.done && (_o = _h.return)) _o.call(_h);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-                // create README.md
-                return [4 /*yield*/, createReadmeFile(argv, deletedPaths)];
-            case 14:
-                // create README.md
-                _q.sent();
-                resultTime = (Math.abs(startTime - +new Date()) / 1000).toFixed(2);
-                console.log("\n\u23F0 Time: ".concat(resultTime, "s"));
-                watchFiles(argv);
-                return [2 /*return*/];
+const createReadmeFile = async (options) => {
+    const { readmePath } = options;
+    // vitepress uses index.md as the page of a folder
+    const target = options.format === 'vitepress' ? 'index.md' : 'README.md';
+    let content = `# ${options.title}\n`;
+    try {
+        content = await fs.readFile(readmePath, 'utf-8');
+        console.log(`${kleur.white().bgBlack(' README ')} ${kleur.dim(readmePath)} → ${kleur.dim(options.docsFolder)}/${target}`);
+    }
+    catch {
+        console.log(`${kleur.white().bgBlack(' README ')} no README.md found, a default one was created`);
+    }
+    await fs.writeFile(path.join(options.docsFolder, target), content);
+};
+const STATUS_COLORS = {
+    [StatisticType.INCLUDE]: kleur.green,
+    [StatisticType.ERROR]: kleur.red,
+    [StatisticType.EMPTY]: kleur.yellow,
+    [StatisticType.EXCLUDE]: kleur.blue
+};
+/**
+ * Print a status line
+ * @param {StatisticType} type
+ * @param {string} message
+ */
+const printStatus = (type, message) => {
+    console.log(STATUS_COLORS[type]()
+        .inverse()
+        .bold(` ${type.padEnd(7)} `), message);
+};
+/**
+ * Print the result of a parsed file
+ * @param {ParseReturn} entry
+ */
+const printResult = (entry) => {
+    const source = `${kleur.dim(entry.file.folder)}${kleur.bold(path.basename(entry.file.path))}`;
+    if (entry.type === StatisticType.INCLUDE) {
+        printStatus(entry.type, `${source} → ${kleur.dim(entry.dest + '/')}${kleur.bold(entry.file.name + '.md')}`);
+    }
+    else if (entry.type === StatisticType.EMPTY) {
+        printStatus(entry.type, `${source} ${kleur.dim('(no documentation found)')}`);
+    }
+    else {
+        printStatus(entry.type, source);
+        if (entry.error) {
+            console.log(kleur.red(entry.error.replace(/^/gm, '          ')));
         }
-    });
-}); };
-exports.generate = generate;
+    }
+};
 /**
- * Watch files in source folder
- * @param {CLIArguments} argv
+ * Default command that generates the markdown files
+ * @param {CLIArguments} argv passed arguments
+ * @returns {Promise<ParseReturn[]>} results of all parsed files
  */
-var watchFiles = function (argv) {
-    var _a = parseArguments(argv), exclude = _a.exclude, include = _a.include, srcFolder = _a.srcFolder, codeFolder = _a.codeFolder, docsFolder = _a.docsFolder, title = _a.title;
+export const generate = async (argv) => {
+    const options = parseArguments(argv);
+    const startTime = performance.now();
+    // the generated folder is always recreated
+    await fs.rm(options.docsFolder, { recursive: true, force: true });
+    if (options.rmPattern.length) {
+        await deleteAsync(options.rmPattern);
+    }
+    await fs.mkdir(options.docsFolder, { recursive: true });
+    const lsFolder = await listFolder(options.srcFolder, options.exclude, options.include);
+    for (const file of lsFolder.excluded) {
+        printStatus(StatisticType.EXCLUDE, `${kleur.dim(file.folder)}${kleur.bold(path.basename(file.path))}`);
+    }
+    const results = await mapLimit(lsFolder.paths, async (file) => {
+        const result = await processFile(file, options);
+        printResult(result);
+        return result;
+    });
+    await Promise.all([createVuepressSidebar(options, lsFolder.tree), createReadmeFile(options)]);
+    const count = (type) => results.filter((r) => r.type === type).length;
+    const resultTime = ((performance.now() - startTime) / 1000).toFixed(2);
+    console.log(`\n${kleur.green(`${count(StatisticType.INCLUDE)} generated`)}, ${kleur.yellow(`${count(StatisticType.EMPTY)} empty`)}, ${kleur.red(`${count(StatisticType.ERROR)} failed`)}, ${kleur.blue(`${lsFolder.excluded.length} excluded`)}`);
+    console.log(`⏰ Time: ${resultTime}s`);
     if (argv.watch) {
-        console.log('\n---\n\n👀 watching files...');
-        var watcher = chokidar_1.default.watch([srcFolder, argv.readme, "".concat(srcFolder, "/README.md")].filter(Boolean), {
-            ignored: /(^|[\/\\])\../,
-            persistent: true
-        });
-        watcher.on('change', function (path) { return __awaiter(void 0, void 0, void 0, function () {
-            var lsFolder, file;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, (0, list_folder_1.listFolder)(srcFolder, exclude, include)];
-                    case 1:
-                        lsFolder = _b.sent();
-                        file = lsFolder.paths.find(function (p) { return p.path === path; });
-                        readline_1.default.clearLine(process.stdout, 0);
-                        readline_1.default.cursorTo(process.stdout, 0);
-                        if (!(path === 'README.md' || path === "".concat(srcFolder, "/README.md"))) return [3 /*break*/, 3];
-                        return [4 /*yield*/, createReadmeFile(argv)];
-                    case 2:
-                        _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        if (file) {
-                            process.stdout.write(chalk_1.default.dim("update ".concat(file.name + file.ext)));
-                            (_a = parseDirectoryFile(file, argv)) === null || _a === void 0 ? void 0 : _a.then(function (data) {
-                                if (data) {
-                                    (0, parser_1.writeContentToFile)(data, data.relativePathDest);
-                                }
-                                createVuepressSidebar({
-                                    fileTree: lsFolder.tree,
-                                    srcFolder: srcFolder,
-                                    docsFolder: docsFolder,
-                                    codeFolder: codeFolder,
-                                    title: title
-                                });
-                            });
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        }); });
+        watchFiles(argv);
     }
+    return results;
 };
 /**
- * The vuepress plugins
+ * Watch files in source folder and update the generated markdown files
  * @param {CLIArguments} argv
- * @param {object} ctx
- * @returns {object}
+ * @returns {object} chokidar watcher
  */
-var plugin = function (argv, ctx) { return ({
-    name: 'vuepress-plugin-jsdoc',
-    ready: function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            if (!ctx.isProd) {
-                argv.watch = true;
-                watchFiles(argv);
+export const watchFiles = (argv) => {
+    const options = parseArguments(argv);
+    const readmePath = path.resolve(options.readmePath);
+    console.log('\n---\n\n👀 watching files...');
+    const watcher = chokidar.watch([options.srcFolder, options.readme].filter((p) => Boolean(p)), {
+        ignored: (p) => /(^|[/\\])\.[^/\\]/.test(p) || p.includes('node_modules'),
+        ignoreInitial: true
+    });
+    let queue = Promise.resolve();
+    const update = (event, changedPath) => {
+        queue = queue.then(async () => {
+            try {
+                if (path.resolve(changedPath) === readmePath) {
+                    await createReadmeFile(options);
+                    return;
+                }
+                const { paths, tree } = await listFolder(options.srcFolder, options.exclude, options.include);
+                const file = paths.find((p) => path.resolve(p.path) === path.resolve(changedPath));
+                if (event === 'unlink') {
+                    const dir = normalizePath(path.dirname(changedPath));
+                    const name = getPageName(dir, path.basename(changedPath, path.extname(changedPath)));
+                    const dest = getDestFolder({ folder: dir }, options.srcFolder, options.docsFolder);
+                    await fs.rm(path.join(dest, `${name}.md`), { force: true });
+                    console.log(kleur.dim(`removed ${changedPath}`));
+                }
+                else if (file) {
+                    printResult(await processFile(file, options));
+                }
+                await createVuepressSidebar(options, tree);
+            }
+            catch (e) {
+                console.error(e);
             }
-            return [2 /*return*/];
         });
-    }); }
-}); };
-exports.default = plugin;
+    };
+    watcher.on('all', (event, p) => {
+        if (event === 'add' || event === 'change' || event === 'unlink')
+            update(event, p);
+    });
+    return watcher;
+};