markmap-cli 0.18.8 → 0.18.9

package/bin/cli.js

@@ -1,8 +1,3 @@
 #!/usr/bin/env node
 
-import { main } from '../dist/index.js';
-
-main().catch(err => {
-  console.error(err);
-  process.exitCode = 1;
-});
+import '../dist/cli.js';

package/dist/assets-fetcher-B4vBLKaX.js

@@ -0,0 +1,72 @@
+import { createWriteStream } from "fs";
+import { stat, mkdir } from "fs/promises";
+import { extractAssets } from "markmap-common";
+import { Transformer } from "markmap-lib";
+import { baseJsPaths } from "markmap-render";
+import { resolve, dirname } from "path";
+import { Readable } from "stream";
+import { finished } from "stream/promises";
+import { l as localProvider, A as ASSETS_PREFIX, t as toolbarAssets, a as config } from "./common-WzXBUz0S.js";
+const providerName = "local-hook";
+async function fetchAssets({
+  assetsDir = config.assetsDir,
+  verbose
+} = {}) {
+  const transformer = new Transformer();
+  transformer.urlBuilder.setProvider(providerName, localProvider);
+  transformer.urlBuilder.provider = providerName;
+  const assets = transformer.getAssets();
+  delete transformer.urlBuilder.providers[providerName];
+  const pluginPaths = extractAssets(assets).filter((url) => url.startsWith(ASSETS_PREFIX)).map((url) => url.slice(ASSETS_PREFIX.length));
+  const resources = transformer.plugins.flatMap(
+    (plugin) => {
+      var _a;
+      return ((_a = plugin.config) == null ? void 0 : _a.resources) || [];
+    }
+  );
+  const paths = [
+    ...baseJsPaths,
+    ...pluginPaths,
+    ...resources,
+    ...extractAssets(toolbarAssets)
+  ];
+  let findingProvider;
+  const findProvider = () => {
+    findingProvider || (findingProvider = transformer.urlBuilder.getFastestProvider());
+    return findingProvider;
+  };
+  await Promise.all(
+    paths.map(async (path) => {
+      const fullPath = resolve(assetsDir, path);
+      let url;
+      await downloadAsset(
+        fullPath,
+        async () => url = transformer.urlBuilder.getFullUrl(path, await findProvider())
+      );
+      if (verbose) {
+        console.log(
+          url ? `Fetched: ${url} -> ${fullPath}` : `Skipped existing file: ${fullPath}`
+        );
+      }
+    })
+  );
+}
+async function downloadAsset(fullPath, resolveUrl) {
+  try {
+    const result = await stat(fullPath);
+    if (result.isFile()) return;
+  } catch {
+  }
+  const url = await resolveUrl();
+  const res = await fetch(url);
+  if (!res.ok || !res.body) throw new Error(`Failed to download: ${url}`);
+  await mkdir(dirname(fullPath), { recursive: true });
+  await finished(
+    Readable.fromWeb(res.body).pipe(
+      createWriteStream(fullPath)
+    )
+  );
+}
+export {
+  fetchAssets as f
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,57 @@
+import { program } from "commander";
+import { readFile } from "fs/promises";
+import open from "open";
+import { basename } from "path";
+import { readPackageUp } from "read-package-up";
+import updateNotifier from "update-notifier";
+import { fileURLToPath } from "url";
+import { develop, createMarkmap } from "./index.js";
+import { f as fetchAssets } from "./assets-fetcher-B4vBLKaX.js";
+async function main() {
+  var _a;
+  const pkg = (_a = await readPackageUp({
+    cwd: fileURLToPath(import.meta.url)
+  })) == null ? void 0 : _a.packageJson;
+  if (!pkg) throw new Error("Invalid package");
+  const notifier = updateNotifier({ pkg });
+  notifier.notify();
+  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 the 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"
+  ).option("--port <port>", "Set the port for the devServer to listen").action(async (input, cmd) => {
+    let { offline } = cmd;
+    if (cmd.watch) offline = true;
+    if (offline) await fetchAssets();
+    const content = await readFile(input, "utf8");
+    const output = cmd.output || `${input.replace(/\.\w*$/, "")}.html`;
+    if (cmd.watch) {
+      const devServer = await develop({
+        toolbar: cmd.toolbar,
+        offline,
+        port: +cmd.port || void 0
+      });
+      const address = devServer.serverInfo.address;
+      const provider = devServer.addProvider({ filePath: input });
+      const filename = basename(input);
+      const url = `http://localhost:${address.port}/?key=${provider.key}&filename=${encodeURIComponent(filename)}`;
+      console.log(`Listening at ${url}`);
+      if (cmd.open) open(url);
+    } else {
+      await createMarkmap({
+        content,
+        output,
+        open: cmd.open,
+        toolbar: cmd.toolbar,
+        offline
+      });
+    }
+  });
+  program.parse();
+}
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/dist/common-WzXBUz0S.js

@@ -0,0 +1,61 @@
+import { buildCSSItem, buildJSItem } from "markmap-common";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const TOOLBAR_VERSION = "0.18.9";
+const TOOLBAR_CSS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/style.css`;
+const TOOLBAR_JS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/index.js`;
+const distDir = dirname(fileURLToPath(import.meta.url));
+const ASSETS_PREFIX = "/assets/";
+const renderToolbar = () => {
+  const { markmap, mm } = window;
+  const toolbar = new markmap.Toolbar();
+  toolbar.attach(mm);
+  const el = toolbar.render();
+  el.setAttribute("style", "position:absolute;bottom:20px;right:20px");
+  document.body.append(el);
+};
+const toolbarAssets = {
+  styles: [buildCSSItem(TOOLBAR_CSS)],
+  scripts: [
+    buildJSItem(TOOLBAR_JS),
+    {
+      type: "iife",
+      data: {
+        fn: (r) => {
+          setTimeout(r);
+        },
+        getParams: () => [renderToolbar]
+      }
+    }
+  ]
+};
+function localProvider(path) {
+  return `${ASSETS_PREFIX}${path}`;
+}
+function createStreamBody(stream) {
+  const body = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => {
+        controller.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        controller.close();
+      });
+    },
+    cancel() {
+      stream.destroy();
+    }
+  });
+  return body;
+}
+const config = {
+  distDir,
+  assetsDir: `${distDir}${ASSETS_PREFIX}`
+};
+export {
+  ASSETS_PREFIX as A,
+  config as a,
+  createStreamBody as c,
+  localProvider as l,
+  toolbarAssets as t
+};

package/dist/fetch-assets.d.ts

@@ -1 +1 @@
-export declare function fetchAssets(assetsDir?: string): Promise<void>;
+export {};

package/dist/fetch-assets.js

@@ -0,0 +1,11 @@
+import { program } from "commander";
+import { f as fetchAssets } from "./assets-fetcher-B4vBLKaX.js";
+program.description("Fetch assets for markmap-cli").option("--ignoreErrors", "Ignore errors when failing to download assets").option("--verbose", "Show verbose logs").action(async (cmd) => {
+  try {
+    await fetchAssets({ verbose: cmd.verbose });
+  } catch (err) {
+    console.error(err);
+    if (!cmd.ignoreErrors) process.exitCode = 1;
+  }
+});
+program.parse();

package/dist/index.d.ts

@@ -1,12 +1,10 @@
 import { type IMarkmapCreateOptions } from 'markmap-lib';
-import { fetchAssets } from './fetch-assets';
 import { IDevelopOptions } from './types';
-import { config } from './util';
-export * from './dev-server';
+import { config } from './util/common';
 export * from './types';
-export { config, fetchAssets };
+export * from './util/dev-server';
+export { config };
 export * as markmap from 'markmap-lib';
 export declare function createMarkmap(options: IMarkmapCreateOptions & IDevelopOptions & {
     open: boolean;
 }): Promise<void>;
-export declare function main(): Promise<void>;

package/dist/index.js

@@ -1,22 +1,17 @@
-import { Command } from "commander";
-import { readFile, stat, mkdir, writeFile } from "fs/promises";
-import { buildCSSItem, buildJSItem, mergeAssets, defer, extractAssets } from "markmap-common";
+import { readFile, stat, writeFile } from "fs/promises";
+import { mergeAssets, defer, buildJSItem } from "markmap-common";
 import { Transformer } from "markmap-lib";
 import * as markmapLib from "markmap-lib";
 import { fillTemplate, baseJsPaths } from "markmap-render";
 import open from "open";
-import { dirname, join, resolve, basename } from "path";
-import { readPackageUp } from "read-package-up";
-import updateNotifier from "update-notifier";
-import { fileURLToPath } from "url";
+import { join, resolve } from "path";
+import { t as toolbarAssets, A as ASSETS_PREFIX, l as localProvider, c as createStreamBody, a as config } from "./common-WzXBUz0S.js";
 import { serve } from "@hono/node-server";
 import { watch } from "chokidar";
 import { createHash } from "crypto";
-import { createReadStream, createWriteStream } from "fs";
+import { createReadStream } from "fs";
 import { Hono } from "hono";
 import { getPortPromise } from "portfinder";
-import { Readable } from "stream";
-import { finished } from "stream/promises";
 var getMimeType = (filename, mimes = baseMimes) => {
   const regexp = /\.([a-zA-Z0-9]+?)$/;
   const match = filename.match(regexp);
@@ -87,57 +82,6 @@ var _baseMimes = {
   glb: "model/gltf-binary"
 };
 var baseMimes = _baseMimes;
-const TOOLBAR_VERSION = "0.18.8";
-const TOOLBAR_CSS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/style.css`;
-const TOOLBAR_JS = `markmap-toolbar@${TOOLBAR_VERSION}/dist/index.js`;
-const distDir = dirname(fileURLToPath(import.meta.url));
-const ASSETS_PREFIX = "/assets/";
-const renderToolbar = () => {
-  const { markmap, mm } = window;
-  const toolbar = new markmap.Toolbar();
-  toolbar.attach(mm);
-  const el = toolbar.render();
-  el.setAttribute("style", "position:absolute;bottom:20px;right:20px");
-  document.body.append(el);
-};
-const toolbarAssets = {
-  styles: [buildCSSItem(TOOLBAR_CSS)],
-  scripts: [
-    buildJSItem(TOOLBAR_JS),
-    {
-      type: "iife",
-      data: {
-        fn: (r) => {
-          setTimeout(r);
-        },
-        getParams: () => [renderToolbar]
-      }
-    }
-  ]
-};
-function localProvider(path) {
-  return `${ASSETS_PREFIX}${path}`;
-}
-function createStreamBody(stream) {
-  const body = new ReadableStream({
-    start(controller) {
-      stream.on("data", (chunk) => {
-        controller.enqueue(chunk);
-      });
-      stream.on("end", () => {
-        controller.close();
-      });
-    },
-    cancel() {
-      stream.destroy();
-    }
-  });
-  return body;
-}
-const config = {
-  distDir,
-  assetsDir: `${distDir}${ASSETS_PREFIX}`
-};
 function sequence(fn) {
   let promise;
   return () => {
@@ -325,9 +269,9 @@ class MarkmapDevServer {
       await ((_a = provider[cmd]) == null ? void 0 : _a.call(provider, ...args));
       return c.body(null, 204);
     });
-    const { distDir: distDir2, assetsDir } = config;
+    const { distDir, assetsDir } = config;
     app.get("/~client.*", async (c) => {
-      const realpath = join(distDir2, c.req.path.slice(2));
+      const realpath = join(distDir, c.req.path.slice(2));
       return sendStatic(c, realpath);
     });
     app.get(`${ASSETS_PREFIX}*`, async (c) => {
@@ -404,56 +348,6 @@ async function develop(options) {
   await devServer.setup();
   return devServer;
 }
-const providerName = "local-hook";
-async function fetchAssets(assetsDir = config.assetsDir) {
-  const transformer = new Transformer();
-  transformer.urlBuilder.setProvider(providerName, localProvider);
-  transformer.urlBuilder.provider = providerName;
-  const assets = transformer.getAssets();
-  delete transformer.urlBuilder.providers[providerName];
-  const pluginPaths = extractAssets(assets).filter((url) => url.startsWith(ASSETS_PREFIX)).map((url) => url.slice(ASSETS_PREFIX.length));
-  const resources = transformer.plugins.flatMap(
-    (plugin) => {
-      var _a;
-      return ((_a = plugin.config) == null ? void 0 : _a.resources) || [];
-    }
-  );
-  const paths = [
-    ...baseJsPaths,
-    ...pluginPaths,
-    ...resources,
-    ...extractAssets(toolbarAssets)
-  ];
-  let findingProvider;
-  const findProvider = () => {
-    findingProvider || (findingProvider = transformer.urlBuilder.getFastestProvider());
-    return findingProvider;
-  };
-  await Promise.all(
-    paths.map(
-      (path) => downloadAsset(
-        resolve(assetsDir, path),
-        async () => transformer.urlBuilder.getFullUrl(path, await findProvider())
-      )
-    )
-  );
-}
-async function downloadAsset(fullPath, resolveUrl) {
-  try {
-    const result = await stat(fullPath);
-    if (result.isFile()) return;
-  } catch {
-  }
-  const url = await resolveUrl();
-  const res = await fetch(url);
-  if (!res.ok || !res.body) throw new Error(`Failed to download: ${url}`);
-  await mkdir(dirname(fullPath), { recursive: true });
-  await finished(
-    Readable.fromWeb(res.body).pipe(
-      createWriteStream(fullPath)
-    )
-  );
-}
 async function loadFile(path) {
   if (path.startsWith(ASSETS_PREFIX)) {
     const relpath = path.slice(ASSETS_PREFIX.length);
@@ -527,57 +421,10 @@ async function createMarkmap(options) {
   await writeFile(output, html, "utf8");
   if (options.open) open(output);
 }
-async function main() {
-  var _a;
-  const pkg = (_a = await readPackageUp({
-    cwd: fileURLToPath(import.meta.url)
-  })) == null ? void 0 : _a.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 the 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"
-  ).option("--port <port>", "Set the port for the devServer to listen").action(async (input, cmd) => {
-    let { offline } = cmd;
-    if (cmd.watch) offline = true;
-    if (offline) await fetchAssets();
-    const content = await readFile(input, "utf8");
-    const output = cmd.output || `${input.replace(/\.\w*$/, "")}.html`;
-    if (cmd.watch) {
-      const devServer = await develop({
-        toolbar: cmd.toolbar,
-        offline,
-        port: +cmd.port || void 0
-      });
-      const address = devServer.serverInfo.address;
-      const provider = devServer.addProvider({ filePath: input });
-      const filename = basename(input);
-      const url = `http://localhost:${address.port}/?key=${provider.key}&filename=${encodeURIComponent(filename)}`;
-      console.log(`Listening at ${url}`);
-      if (cmd.open) open(url);
-    } else {
-      await createMarkmap({
-        content,
-        output,
-        open: cmd.open,
-        toolbar: cmd.toolbar,
-        offline
-      });
-    }
-  });
-  program.parse(process.argv);
-}
 export {
   MarkmapDevServer,
   config,
   createMarkmap,
   develop,
-  fetchAssets,
-  main,
   markmapLib as markmap
 };

package/dist/util/assets-fetcher.d.ts

@@ -0,0 +1,4 @@
+export declare function fetchAssets({ assetsDir, verbose, }?: {
+    assetsDir?: string;
+    verbose?: boolean;
+}): Promise<void>;

package/dist/{dev-server.d.ts → util/dev-server.d.ts}

@@ -1,7 +1,7 @@
 import { ServerType } from '@hono/node-server';
 import { Transformer } from 'markmap-lib';
 import { AddressInfo } from 'net';
-import { IContentProvider, IDevelopOptions } from './types';
+import { IContentProvider, IDevelopOptions } from '../types';
 export declare class MarkmapDevServer {
     options: IDevelopOptions;
     providers: Record<string, IContentProvider>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markmap-cli",
-  "version": "0.18.8",
+  "version": "0.18.9",
   "description": "Create markmaps from CLI",
   "author": "Gerald <gera2ld@live.com>",
   "license": "MIT",
@@ -30,7 +30,7 @@
     "build:js": "vite build",
     "build": "pnpm clean && pnpm /^build:/",
     "prepublishOnly": "pnpm build",
-    "postinstall": "node -e \"import('./dist/index.js').then(({ fetchAssets }) => fetchAssets()).catch(() => {})\""
+    "postinstall": "node ./dist/fetch-assets.js --ignoreErrors"
   },
   "bugs": {
     "url": "https://github.com/markmap/markmap/issues"
@@ -49,14 +49,14 @@
     "chokidar": "^4.0.1",
     "commander": "^12.1.0",
     "hono": "^4.6.13",
-    "markmap-common": "0.18.8",
-    "markmap-lib": "0.18.8",
-    "markmap-render": "0.18.8",
-    "markmap-toolbar": "0.18.8",
+    "markmap-common": "0.18.9",
+    "markmap-lib": "0.18.9",
+    "markmap-render": "0.18.9",
+    "markmap-toolbar": "0.18.9",
     "open": "^10.1.0",
     "portfinder": "^1.0.32",
     "read-package-up": "^11.0.0",
     "update-notifier": "^7.3.1"
   },
-  "gitHead": "476d2e8abb528af6f6f0c468c6c63791b7c1911a"
+  "gitHead": "4247555f57017ffc9297e5e5e031c4119de3ebaf"
 }