markmap-cli 0.14.4 → 0.14.5-alpha.15

package/dist/index.js

@@ -1,26 +1,35 @@
-/*! markmap-cli v0.14.4 | MIT License */
+/*! markmap-cli v0.14.5-alpha.15+1fe26c8 | MIT License */
 'use strict';
 
 var fs = require('fs');
 var commander = require('commander');
 var open = require('open');
+var markmapCommon = require('markmap-common');
 var markmapLib = require('markmap-lib');
+var path = require('path');
 var events = require('events');
 var http = require('http');
 var Koa = require('koa');
 var chokidar = require('chokidar');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var open__default = /*#__PURE__*/_interopDefaultLegacy(open);
-var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
-var Koa__default = /*#__PURE__*/_interopDefaultLegacy(Koa);
-var chokidar__default = /*#__PURE__*/_interopDefaultLegacy(chokidar);
-
-const TOOLBAR_VERSION = "0.14.4";
-const TOOLBAR_CSS = `npm/markmap-toolbar@${TOOLBAR_VERSION}/dist/style.min.css`;
-const TOOLBAR_JS = `npm/markmap-toolbar@${TOOLBAR_VERSION}/dist/index.umd.min.js`;
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
 
+const TOOLBAR_VERSION = "0.14.5-alpha.15+1fe26c8";
+const TOOLBAR_CSS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/style.css`;
+const TOOLBAR_JS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/index.js`;
 const renderToolbar = () => {
   const {
     markmap,
@@ -32,21 +41,10 @@ const renderToolbar = () => {
   el.setAttribute('style', 'position:absolute;bottom:20px;right:20px');
   document.body.append(el);
 };
-
 function addToolbar(assets) {
   return {
-    styles: [...(assets.styles || []), {
-      type: 'stylesheet',
-      data: {
-        href: `https://cdn.jsdelivr.net/${TOOLBAR_CSS}`
-      }
-    }],
-    scripts: [...(assets.scripts || []), {
-      type: 'script',
-      data: {
-        src: `https://cdn.jsdelivr.net/${TOOLBAR_JS}`
-      }
-    }, {
+    styles: [...(assets.styles || []), ...[TOOLBAR_CSS].map(path => markmapCommon.buildCSSItem(path))],
+    scripts: [...(assets.scripts || []), ...[TOOLBAR_JS].map(path => markmapCommon.buildJSItem(path)), {
       type: 'iife',
       data: {
         fn: r => {
@@ -64,25 +62,24 @@ class Defer {
       this.reject = reject;
     });
   }
-
+}
+function localProvider(path) {
+  const parts = path.split('/');
+  parts[0] = parts[0].replace(/@[\d.]+$/, '');
+  path = parts.join('/');
+  return `/node_modules/${path}`;
 }
 
 /* eslint-disable max-classes-per-file */
-
-function consecutive(fn) {
+function sequence(fn) {
   let promise;
   return () => {
-    if (!promise) {
-      promise = fn();
-      promise.catch(() => {}).then(() => {
-        promise = null;
-      });
-    }
-
+    promise || (promise = fn().finally(() => {
+      promise = null;
+    }));
     return promise;
   };
 }
-
 class BufferContentProvider {
   constructor() {
     this.deferredSet = new Set();
@@ -100,24 +97,20 @@ class BufferContentProvider {
       });
     });
   }
-
   async getUpdate(ts, timeout = 10000) {
     const deferred = new Defer();
     this.deferredSet.add(deferred);
     setTimeout(() => {
       this.feed({}, deferred);
     }, timeout);
-
     if (ts < this.ts) {
       this.feed({
         ts: this.ts,
         content: this.content
       }, deferred);
     }
-
     return deferred.promise;
   }
-
   feed(data, deferred) {
     if (deferred) {
       deferred.resolve(data);
@@ -126,45 +119,37 @@ class BufferContentProvider {
       for (const d of this.deferredSet) {
         d.resolve(data);
       }
-
       this.deferredSet.clear();
     }
   }
-
   setCursor(line) {
     this.line = line;
     this.events.emit('cursor');
   }
-
   setContent(content) {
     this.ts = Date.now();
     this.content = content;
     this.events.emit('content');
   }
-
-  dispose() {}
-
+  dispose() {
+    /* noop */
+  }
 }
-
 class FileSystemProvider extends BufferContentProvider {
   constructor(fileName) {
     super();
     this.fileName = fileName;
-    this.watcher = chokidar__default.watch(fileName).on('all', consecutive(() => this.update()));
+    this.watcher = chokidar.watch(fileName).on('all', sequence(() => this.update()));
   }
-
   async update() {
     const content = await fs.promises.readFile(this.fileName, 'utf8');
     this.setContent(content);
   }
-
   dispose() {
     super.dispose();
     this.watcher.close();
   }
-
 }
-
 function startServer(paddingBottom) {
   let ts = 0;
   const {
@@ -172,30 +157,28 @@ function startServer(paddingBottom) {
     markmap
   } = window;
   refresh();
-
   function refresh() {
     fetch(`/data?ts=${ts}`).then(res => res.json()).then(res => {
       if (res.ts && res.ts > ts && res.result) {
         const {
           root,
-          frontmatter
+          frontmatter,
+          contentLineOffset
         } = res.result;
         mm.setOptions(markmap.deriveOptions(frontmatter == null ? void 0 : frontmatter.markmap));
         mm.setData(root);
         if (!ts) mm.fit();
         ts = res.ts;
       }
-
       setTimeout(refresh, 300);
     });
   }
 }
-
 function setUpServer(transformer, provider, options) {
   let assets = transformer.getAssets();
   if (options.toolbar) assets = addToolbar(assets);
   const html = `${markmapLib.fillTemplate(null, assets)}<script>(${startServer.toString()})(${options.toolbar ? 60 : 0})</script>`;
-  const app = new Koa__default();
+  const app = new Koa();
   app.use(async (ctx, next) => {
     if (ctx.path === '/') {
       ctx.body = html;
@@ -208,42 +191,79 @@ function setUpServer(transformer, provider, options) {
         line: update.line
       };
     } else {
+      if (ctx.path.startsWith('/node_modules/')) {
+        const relpath = ctx.path.slice(14);
+        try {
+          const realpath = require.resolve(relpath);
+          ctx.type = path.extname(relpath);
+          ctx.body = fs.createReadStream(realpath);
+          return;
+        } catch (_unused) {
+          // ignore
+        }
+      }
       await next();
     }
   });
   const handle = app.callback();
-  const server = http__default.createServer(handle);
+  const server = http.createServer(handle);
   server.listen(() => {
     const {
       port
     } = server.address();
     console.info(`Listening at http://localhost:${port}`);
-    if (options.open) open__default(`http://localhost:${port}`);
+    if (options.open) open(`http://localhost:${port}`);
   });
   let closing;
   return {
     provider,
-
     close() {
       if (!closing) {
         closing = new Promise((resolve, reject) => server.close(err => {
           if (err) reject(err);else resolve();
         }));
       }
-
       return closing;
     }
-
   };
 }
-
 async function develop(fileName, options) {
+  markmapCommon.setProvider('local', localProvider);
   const transformer = new markmapLib.Transformer();
   const provider = fileName ? new FileSystemProvider(fileName) : new BufferContentProvider();
   return setUpServer(transformer, provider, options);
 }
 
+async function loadFile(path) {
+  if (path.startsWith('/node_modules/')) {
+    const relpath = path.slice(14);
+    return fs.promises.readFile(require.resolve(relpath), 'utf8');
+  }
+  const res = await fetch(path);
+  if (!res.ok) throw res;
+  return res.text();
+}
+async function inlineAssets(assets) {
+  const [scripts, styles] = await Promise.all([Promise.all((assets.scripts || []).map(async item => item.type === 'script' && item.data.src ? {
+    type: 'script',
+    data: {
+      textContent: await loadFile(item.data.src)
+    }
+  } : item)), Promise.all((assets.styles || []).map(async item => item.type === 'stylesheet' ? {
+    type: 'style',
+    data: await loadFile(item.data.href)
+  } : item))]);
+  return {
+    scripts,
+    styles
+  };
+}
 async function createMarkmap(options) {
+  if (options.offline) {
+    markmapCommon.setProvider('local', localProvider);
+  } else {
+    await markmapCommon.findFastestProvider();
+  }
   const transformer = new markmapLib.Transformer();
   const {
     root,
@@ -251,31 +271,41 @@ async function createMarkmap(options) {
     frontmatter
   } = transformer.transform(options.content || '');
   let assets = transformer.getUsedAssets(features);
-  if (options.toolbar) assets = addToolbar(assets);
+  assets = _extends({}, assets, {
+    scripts: [...markmapLib.baseJsPaths.map(path => markmapCommon.buildJSItem(path)), ...(assets.scripts || [])]
+  });
+  if (options.toolbar) {
+    assets = addToolbar(assets);
+  }
+  if (options.offline) {
+    assets = await inlineAssets(assets);
+  }
   const html = markmapLib.fillTemplate(root, assets, {
+    baseJs: [],
     jsonOptions: frontmatter == null ? void 0 : frontmatter.markmap
   });
   const output = options.output || 'markmap.html';
   await fs.promises.writeFile(output, html, 'utf8');
-  if (options.open) open__default(output);
+  if (options.open) open(output);
 }
 function main(version) {
   const program = new commander.Command();
-  program.version(version).description('Create a markmap from a Markdown input file').arguments('<input>').option('--no-open', 'do not open the output file after generation').option('--no-toolbar', 'do not show toolbar').option('-o, --output <output>', 'specify filename of the output HTML').option('-w, --watch', 'watch the input file and update output on the fly, note that this feature is for development only').action(async (input, cmd) => {
+  program.version(version).description('Create a markmap from a Markdown input file').arguments('<input>').option('--no-open', 'do not open the output file after generation').option('--no-toolbar', 'do not show toolbar').option('-o, --output <output>', 'specify filename of the output HTML').option('--offline', 'Inline all assets to allow the generated HTML to work offline').option('-w, --watch', 'watch the input file and update output on the fly, note that this feature is for development only').action(async (input, cmd) => {
     const content = await fs.promises.readFile(input, 'utf8');
     const output = cmd.output || `${input.replace(/\.\w*$/, '')}.html`;
-
     if (cmd.watch) {
       await develop(input, {
         open: cmd.open,
-        toolbar: cmd.toolbar
+        toolbar: cmd.toolbar,
+        offline: true
       });
     } else {
       await createMarkmap({
         content,
         output,
         open: cmd.open,
-        toolbar: cmd.toolbar
+        toolbar: cmd.toolbar,
+        offline: cmd.offline
       });
     }
   });
@@ -285,6 +315,6 @@ function main(version) {
 exports.createMarkmap = createMarkmap;
 exports.develop = develop;
 exports.main = main;
-for (var k in markmapLib) {
-if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = markmapLib[k];
-}
+Object.keys(markmapLib).forEach(function (k) {
+if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = markmapLib[k];
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markmap-cli",
-  "version": "0.14.4",
+  "version": "0.14.5-alpha.15+1fe26c8",
   "description": "Create markmaps from CLI",
   "author": "Gerald <gera2ld@live.com>",
   "license": "MIT",
@@ -12,14 +12,14 @@
     "markdown",
     "mindmap"
   ],
-  "homepage": "https://github.com/gera2ld/markmap/packages/markmap-cli#readme",
+  "homepage": "https://github.com/markmap/markmap/packages/markmap-cli#readme",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gera2ld/markmap.git"
+    "url": "git+https://github.com/markmap/markmap.git"
   },
   "scripts": {
     "dev": "rollup -wc rollup.conf.js",
@@ -28,7 +28,7 @@
     "build:js": "rollup -c rollup.conf.js"
   },
   "bugs": {
-    "url": "https://github.com/gera2ld/markmap/issues"
+    "url": "https://github.com/markmap/markmap/issues"
   },
   "main": "dist/index.js",
   "files": [
@@ -41,17 +41,17 @@
     "@babel/runtime": "^7.13.10",
     "chokidar": "^3.5.1",
     "commander": "^7.1.0",
+    "d3": "^6.2.0",
+    "katex": "^0.16.0",
     "koa": "^2.13.1",
-    "markmap-common": "^0.14.2",
-    "markmap-lib": "^0.14.4",
+    "markmap-common": "0.14.5-alpha.15+1fe26c8",
+    "markmap-lib": "0.14.5-alpha.15+1fe26c8",
+    "markmap-toolbar": "0.14.5-alpha.15+1fe26c8",
+    "markmap-view": "0.14.5-alpha.15+1fe26c8",
     "open": "^8.0.3",
-    "update-notifier": "^5.1.0"
+    "prismjs": "^1.28.0",
+    "update-notifier": "^5.1.0",
+    "webfontloader": "^1.6.28"
   },
-  "devDependencies": {
-    "markmap-view": "^0.14.4"
-  },
-  "engines": {
-    "node": ">=10"
-  },
-  "gitHead": "8eb2fa223ab85d1a7699d2c9660fdb5fac24acd1"
+  "gitHead": "1fe26c8234296e2188e466c7b9dbf3b7e171857d"
 }

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import type { IMarkmapCreateOptions } from 'markmap-lib';
+import { type IMarkmapCreateOptions } from 'markmap-lib';
 import { IDevelopOptions } from './util';
 import { develop } from './dev-server';
 export * from 'markmap-lib';

package/types/util.d.ts

@@ -1,13 +1,18 @@
 import { IAssets } from 'markmap-lib';
 export interface IDevelopOptions {
     /**
-     * whether to open the generated markmap in browser
+     * Whether to open the generated markmap in browser
      */
     open: boolean;
     /**
-     * whether to show default toolbar
+     * Whether to show the default toolbar
      */
     toolbar: boolean;
+    /**
+     * Whether to inline all assets to make the HTML work offline.
+     * Ignored in watching mode.
+     */
+    offline: boolean;
 }
 export declare function addToolbar(assets: IAssets): IAssets;
 export declare class Defer<T> {
@@ -15,3 +20,4 @@ export declare class Defer<T> {
     reject: (err: Error) => void;
     promise: Promise<unknown>;
 }
+export declare function localProvider(path: string): string;