markmap-cli 0.15.0-alpha.1 → 0.15.1

package/bin/cli.js

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
-const updateNotifier = require('update-notifier');
-const { main } = require('..');
-const pkg = require('../package.json');
+import { main } from '../dist/index.js';
 
-const notifier = updateNotifier({ pkg });
-notifier.notify();
-main(pkg.version);
+main().catch(err => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/dist/index.js

@@ -1,19 +1,40 @@
-/*! markmap-cli v0.15.0-alpha.1+1308d8e | MIT License */
-'use strict';
+/*! markmap-cli v0.15.1 | MIT License */
+import { readFile, writeFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import open from 'open';
+import updateNotifier from 'update-notifier';
+import { readPackageUp } from 'read-pkg-up';
+import { buildCSSItem, buildJSItem, defer } from 'markmap-common';
+import { Transformer, baseJsPaths } from 'markmap-lib';
+export * from 'markmap-lib';
+import { join, extname } from 'path';
+import { createRequire } from 'module';
+import { packageDirectory } from 'pkg-dir';
+import { createReadStream } from 'fs';
+import { EventEmitter } from 'events';
+import http from 'http';
+import Koa from 'koa';
+import chokidar from 'chokidar';
 
-var fs = require('fs');
-var commander = require('commander');
-var open = require('open');
-var markmapLib = require('markmap-lib');
-var markmapCommon = require('markmap-common');
-var events = require('events');
-var http = require('http');
-var Koa = require('koa');
-var chokidar = require('chokidar');
+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.15.0-alpha.1+1308d8e";
-const TOOLBAR_CSS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/style.min.css`;
-const TOOLBAR_JS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/index.umd.min.js`;
+const TOOLBAR_VERSION = "0.15.0";
+const TOOLBAR_CSS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/style.css`;
+const TOOLBAR_JS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/index.js`;
 const renderToolbar = () => {
   const {
     markmap,
@@ -25,10 +46,10 @@ const renderToolbar = () => {
   el.setAttribute('style', 'position:absolute;bottom:20px;right:20px');
   document.body.append(el);
 };
-function addToolbar(assets) {
+function addToolbar(transformer, assets) {
   return {
-    styles: [...(assets.styles || []), ...[TOOLBAR_CSS].map(markmapCommon.buildCSSItem)],
-    scripts: [...(assets.scripts || []), ...[TOOLBAR_JS].map(markmapCommon.buildJSItem), {
+    styles: [...(assets.styles || []), ...[TOOLBAR_CSS].map(path => transformer.urlBuilder.getFullUrl(path)).map(path => buildCSSItem(path))],
+    scripts: [...(assets.scripts || []), ...[TOOLBAR_JS].map(path => transformer.urlBuilder.getFullUrl(path)).map(path => buildJSItem(path)), {
       type: 'iife',
       data: {
         fn: r => {
@@ -39,21 +60,46 @@ function addToolbar(assets) {
     }]
   };
 }
-class Defer {
-  constructor() {
-    this.promise = new Promise((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
+function removeVersionString(part) {
+  return part.replace(/@.+$/, '');
+}
+function localProvider(path) {
+  const parts = path.split('/');
+  // xxx@0.0.0-alpha.0+aaaaaa
+  // @scope/xxx@0.0.0-alpha.0+aaaaaa
+  if (parts[0].startsWith('@')) {
+    parts[1] = removeVersionString(parts[1]);
+  } else {
+    parts[0] = removeVersionString(parts[0]);
   }
+  path = parts.join('/');
+  return `/node_modules/${path}`;
+}
+const require = createRequire(import.meta.url);
+async function doResolveFile(relpath) {
+  const parts = relpath.split('/');
+  const nameOffset = parts[0].startsWith('@') ? 2 : 1;
+  const name = parts.slice(0, nameOffset).join('/');
+  const filepath = parts.slice(nameOffset).join('/');
+  const mainPath = require.resolve(name);
+  const pkgDir = await packageDirectory({
+    cwd: mainPath
+  });
+  if (!pkgDir) throw new Error(`File not found: ${relpath}`);
+  const realpath = join(pkgDir, filepath);
+  return realpath;
+}
+const cache = {};
+function resolveFile(relpath) {
+  cache[relpath] || (cache[relpath] = doResolveFile(relpath));
+  return cache[relpath];
 }
 
-/* eslint-disable max-classes-per-file */
 function sequence(fn) {
   let promise;
   return () => {
     promise || (promise = fn().finally(() => {
-      promise = null;
+      promise = undefined;
     }));
     return promise;
   };
@@ -61,8 +107,10 @@ function sequence(fn) {
 class BufferContentProvider {
   constructor() {
     this.deferredSet = new Set();
-    this.events = new events.EventEmitter();
+    this.events = new EventEmitter();
     this.ts = 0;
+    this.content = '';
+    this.line = -1;
     this.events.on('content', () => {
       this.feed({
         ts: this.ts,
@@ -76,7 +124,7 @@ class BufferContentProvider {
     });
   }
   async getUpdate(ts, timeout = 10000) {
-    const deferred = new Defer();
+    const deferred = defer();
     this.deferredSet.add(deferred);
     setTimeout(() => {
       this.feed({}, deferred);
@@ -120,7 +168,7 @@ class FileSystemProvider extends BufferContentProvider {
     this.watcher = chokidar.watch(fileName).on('all', sequence(() => this.update()));
   }
   async update() {
-    const content = await fs.promises.readFile(this.fileName, 'utf8');
+    const content = await readFile(this.fileName, 'utf8');
     this.setContent(content);
   }
   dispose() {
@@ -130,6 +178,9 @@ class FileSystemProvider extends BufferContentProvider {
 }
 function startServer(paddingBottom) {
   let ts = 0;
+  let root;
+  let line;
+  let offset = 0;
   const {
     mm,
     markmap
@@ -138,24 +189,48 @@ function startServer(paddingBottom) {
   function refresh() {
     fetch(`/data?ts=${ts}`).then(res => res.json()).then(res => {
       if (res.ts && res.ts > ts && res.result) {
-        const {
+        var _frontmatter;
+        let frontmatter;
+        ({
           root,
           frontmatter,
-          contentLineOffset
-        } = res.result;
-        mm.setOptions(markmap.deriveOptions(frontmatter == null ? void 0 : frontmatter.markmap));
+          contentLineOffset: offset
+        } = res.result);
+        mm.setOptions(markmap.deriveOptions((_frontmatter = frontmatter) == null ? void 0 : _frontmatter.markmap));
         mm.setData(root);
         if (!ts) mm.fit();
         ts = res.ts;
+        line = -1;
+      }
+      if (root && res.line != null && line !== res.line) {
+        line = res.line;
+        const active = findActiveNode();
+        if (active) mm.ensureView(active, {
+          bottom: paddingBottom
+        });
       }
       setTimeout(refresh, 300);
     });
   }
+  function findActiveNode() {
+    const lineWithoutFrontmatter = line - offset;
+    let best;
+    dfs(root);
+    return best;
+    function dfs(node) {
+      var _node$payload, _node$children;
+      const lines = (_node$payload = node.payload) == null ? void 0 : _node$payload.lines;
+      if (lines && lines[0] <= lineWithoutFrontmatter && lineWithoutFrontmatter < lines[1]) {
+        best = node;
+      }
+      (_node$children = node.children) == null ? void 0 : _node$children.forEach(dfs);
+    }
+  }
 }
 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>`;
+  if (options.toolbar) assets = addToolbar(transformer, assets);
+  const html = `${transformer.fillTemplate(null, assets)}<script>(${startServer.toString()})(${options.toolbar ? 60 : 0})</script>`;
   const app = new Koa();
   app.use(async (ctx, next) => {
     if (ctx.path === '/') {
@@ -169,6 +244,17 @@ function setUpServer(transformer, provider, options) {
         line: update.line
       };
     } else {
+      if (ctx.path.startsWith('/node_modules/')) {
+        const relpath = ctx.path.slice(14);
+        try {
+          const realpath = await resolveFile(relpath);
+          ctx.type = extname(relpath);
+          ctx.body = createReadStream(realpath);
+          return;
+        } catch (err) {
+          console.error(err);
+        }
+      }
       await next();
     }
   });
@@ -195,52 +281,99 @@ function setUpServer(transformer, provider, options) {
   };
 }
 async function develop(fileName, options) {
-  const transformer = new markmapLib.Transformer();
+  const transformer = new Transformer();
+  transformer.urlBuilder.setProvider('local', localProvider);
+  transformer.urlBuilder.provider = 'local';
   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 readFile(await resolveFile(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) {
-  const transformer = new markmapLib.Transformer();
+  const transformer = new Transformer();
+  if (options.offline) {
+    transformer.urlBuilder.setProvider('local', localProvider);
+    transformer.urlBuilder.provider = 'local';
+  } else {
+    await transformer.urlBuilder.findFastestProvider();
+  }
   const {
     root,
     features,
     frontmatter
   } = transformer.transform(options.content || '');
   let assets = transformer.getUsedAssets(features);
-  if (options.toolbar) assets = addToolbar(assets);
-  const html = markmapLib.fillTemplate(root, assets, {
+  assets = _extends({}, assets, {
+    scripts: [...baseJsPaths.map(path => transformer.urlBuilder.getFullUrl(path)).map(path => buildJSItem(path)), ...(assets.scripts || [])]
+  });
+  if (options.toolbar) {
+    assets = addToolbar(transformer, assets);
+  }
+  if (options.offline) {
+    assets = await inlineAssets(assets);
+  }
+  const html = transformer.fillTemplate(root, assets, {
+    baseJs: [],
     jsonOptions: frontmatter == null ? void 0 : frontmatter.markmap
   });
   const output = options.output || 'markmap.html';
-  await fs.promises.writeFile(output, html, 'utf8');
+  await writeFile(output, html, 'utf8');
   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) => {
-    const content = await fs.promises.readFile(input, 'utf8');
+async function main() {
+  var _await$readPackageUp;
+  const pkg = (_await$readPackageUp = await readPackageUp({
+    cwd: fileURLToPath(import.meta.url)
+  })) == null ? void 0 : _await$readPackageUp.packageJson;
+  if (!pkg) throw new Error('package.json not found');
+  const notifier = updateNotifier({
+    pkg
+  });
+  notifier.notify();
+  const program = new Command();
+  program.version(pkg.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 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
       });
     }
   });
   program.parse(process.argv);
 }
 
-exports.createMarkmap = createMarkmap;
-exports.develop = develop;
-exports.main = main;
-Object.keys(markmapLib).forEach(function (k) {
-if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = markmapLib[k];
-});
+export { createMarkmap, develop, main };

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "markmap-cli",
-  "version": "0.15.0-alpha.1+1308d8e",
+  "version": "0.15.1",
   "description": "Create markmaps from CLI",
   "author": "Gerald <gera2ld@live.com>",
   "license": "MIT",
   "bin": {
     "markmap": "bin/cli.js"
   },
+  "engines": {
+    "node": ">=16"
+  },
   "keywords": [
     "markmap",
     "markdown",
@@ -22,15 +25,17 @@
     "url": "git+https://github.com/markmap/markmap.git"
   },
   "scripts": {
-    "dev": "rollup -wc rollup.conf.js",
+    "dev": "rollup -wc",
     "clean": "del-cli dist types",
     "build:types": "tsc",
-    "build:js": "rollup -c rollup.conf.js"
+    "build:js": "rollup -c"
   },
   "bugs": {
     "url": "https://github.com/markmap/markmap/issues"
   },
+  "type": "module",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "files": [
     "bin",
     "dist",
@@ -38,18 +43,23 @@
   ],
   "typings": "types/index.d.ts",
   "dependencies": {
-    "@babel/runtime": "^7.13.10",
-    "chokidar": "^3.5.1",
-    "commander": "^7.1.0",
-    "koa": "^2.13.1",
-    "markmap-common": "0.15.0-alpha.0",
-    "markmap-lib": "0.15.0-alpha.0",
-    "open": "^8.0.3",
-    "update-notifier": "^5.1.0"
-  },
-  "devDependencies": {
-    "markmap-toolbar": "0.15.0-alpha.1+1308d8e",
-    "markmap-view": "0.15.0-alpha.0"
+    "@babel/runtime": "^7.22.6",
+    "chokidar": "^3.5.3",
+    "commander": "^11.0.0",
+    "d3": "^7.8.5",
+    "highlight.js": "^11.8.0",
+    "katex": "^0.16.8",
+    "koa": "^2.14.2",
+    "markmap-common": "0.15.0",
+    "markmap-lib": "0.15.1",
+    "markmap-toolbar": "0.15.0",
+    "markmap-view": "0.15.0",
+    "open": "^9.1.0",
+    "pkg-dir": "^7.0.0",
+    "prismjs": "^1.29.0",
+    "read-pkg-up": "^10.0.0",
+    "update-notifier": "^6.0.2",
+    "webfontloader": "^1.6.28"
   },
-  "gitHead": "1308d8ea5a6e6b24b6c5f053a50cc319df4ad93d"
+  "gitHead": "66edd3e66f16930d15d763ec0ea7239372f3b9c8"
 }

package/types/index.d.ts

@@ -4,4 +4,4 @@ import { develop } from './dev-server';
 export * from 'markmap-lib';
 export { develop };
 export declare function createMarkmap(options: IMarkmapCreateOptions & IDevelopOptions): Promise<void>;
-export declare function main(version: string): void;
+export declare function main(): Promise<void>;

package/types/util.d.ts

@@ -1,17 +1,19 @@
-import { IAssets } from 'markmap-lib';
+import { IAssets, ITransformer } 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> {
-    resolve: (value: T) => void;
-    reject: (err: Error) => void;
-    promise: Promise<unknown>;
-}
+export declare function addToolbar(transformer: ITransformer, assets: IAssets): IAssets;
+export declare function localProvider(path: string): string;
+export declare function resolveFile(relpath: string): Promise<string>;