@markmap/cli 0.0.0-stage → 1.0.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Gerald
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @markmap/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Turn Markdown into a map from the command line.
+
+See the [Markmap README](https://github.com/markmap/markmap#readme) for how the packages fit together.

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { toPlainText } from "@markmap/core";
+import { createPage, remarkReplaceImages, walk } from "@markmap/page";
+import { parse as parse$1 } from "@markmap/parse";
+import { mathContent, remarkMath } from "@markmap/plugin-math";
+import { approximateMeasurer, createImageContent, defaultContentPlugins, renderTreeAsync, resolveRenderOptions, toSVGString } from "@markmap/render";
+// src/inline-images.ts
+/** The types `sanitizeImageUrl` lets through as data URLs. */
+var IMAGE_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif"
+};
+/** Has a scheme, or is `//host/…`: not a file next to the Markdown. */
+var NOT_A_PATH = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+/** The file a URL in the Markdown points at, if it can point at one. */
+function localPath(url, baseDir) {
+	if (!url || NOT_A_PATH.test(url)) return void 0;
+	try {
+		return resolve(baseDir, decodeURI(url));
+	} catch {
+		return;
+	}
+}
+async function toDataUrl(url, baseDir) {
+	const type = IMAGE_TYPES[extname(url).toLowerCase()];
+	if (!type) throw new Error("not a supported image type");
+	const base = await realpath(baseDir);
+	const file = await realpath(resolve(base, decodeURI(url)));
+	const path = relative(base, file);
+	if (path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path)) throw new Error("outside the Markdown file's folder");
+	return `data:${type};base64,${(await readFile(file)).toString("base64")}`;
+}
+/**
+* Data URLs for local images, by the URL in the Markdown. Only files in `baseDir` are
+* read: Markdown from someone else must not be able to pull other files into a page
+* that gets shared. Anything skipped is reported and keeps its URL.
+*/
+async function inlineImages(urls, baseDir, warn) {
+	const images = /* @__PURE__ */ new Map();
+	const local = [...new Set(urls)].filter((url) => localPath(url, baseDir));
+	await Promise.all(local.map(async (url) => {
+		try {
+			images.set(url, await toDataUrl(url, baseDir));
+		} catch (error) {
+			warn(`Image ${url} not included: ${error.code ?? error.message}`);
+		}
+	}));
+	return images;
+}
+// src/main.ts
+var USAGE = `Usage: markmap [options] <file.md>
+
+Writes a map of a Markdown file as one HTML file that works offline. Use - to read
+from stdin.
+
+Options:
+  -o, --output <file>  Where to write; - for stdout. Defaults to the input's name.
+      --svg            Write an SVG image instead
+      --png            Write a PNG image instead
+      --no-open        Do not open the page in a browser
+      --no-toolbar     Leave the toolbar off the page
+  -h, --help           Show this help
+  -v, --version        Show the version
+`;
+var require = createRequire(import.meta.url);
+/** Open a file with whatever the system uses for it. Failing is not worth stopping for. */
+function openFile(file) {
+	const [command, ...args] = process.platform === "darwin" ? ["open"] : process.platform === "win32" ? ["rundll32", "url.dll,FileProtocolHandler"] : ["xdg-open"];
+	const child = spawn(command, [...args, file], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.on("error", () => {});
+	child.unref();
+}
+var defaultIo = {
+	async stdin() {
+		let text = "";
+		for await (const chunk of process.stdin) text += String(chunk);
+		return text;
+	},
+	stdout: (data) => void process.stdout.write(data),
+	stderr: (text) => void process.stderr.write(text),
+	client: (math) => readFile(require.resolve(`@markmap/page/${math ? "client-math" : "client"}.js`), "utf8"),
+	open: openFile
+};
+/** Image URLs in a document, and whether it has math. */
+function inspect(markdown) {
+	const urls = [];
+	let math = false;
+	const visit = (node) => {
+		if (node.type === "image") urls.push(node.url);
+		const { type } = node;
+		if (type === "math" || type === "inlineMath") math = true;
+	};
+	parse$1(markdown, { plugins: [remarkMath, () => (tree) => walk(tree, visit)] });
+	return {
+		urls,
+		math
+	};
+}
+/** Folds as a view would start with them; exports have no reader to unfold anything. */
+function startFolded(root, foldLevel) {
+	const folded = /* @__PURE__ */ new Set();
+	const visit = (node, depth, foldAll) => {
+		const all = foldAll || !!node.data.foldAll;
+		const byLevel = typeof foldLevel === "number" && depth >= foldLevel;
+		if (node.children.length && (all || node.data.fold || byLevel)) folded.add(node.id);
+		for (const child of node.children) visit(child, depth + 1, all);
+	};
+	visit(root, 0, false);
+	return folded;
+}
+async function writeHtml(source, toolbar, io) {
+	const { urls, math } = inspect(source.markdown);
+	const { file, markdown } = source;
+	const images = file ? await inlineImages(urls, dirname(file), warnWith(io)) : /* @__PURE__ */ new Map();
+	const { root, frontmatter } = parse$1(markdown);
+	const title = typeof frontmatter.title === "string" ? frontmatter.title : void 0;
+	return createPage({
+		title: title || toPlainText(root.content) || (file ? basename(file) : "Markmap"),
+		data: {
+			markdown,
+			images: Object.fromEntries(images),
+			toolbar
+		},
+		script: await io.client(math)
+	});
+}
+var warnWith = (io) => (message) => io.stderr(`${message}\n`);
+/** Frontmatter options, with what was ignored reported. */
+function documentOptions({ frontmatter }, io) {
+	const { options, json, warnings } = resolveRenderOptions({ plugins: [...defaultContentPlugins, mathContent] }, frontmatter.markmap);
+	warnings.forEach(warnWith(io));
+	return {
+		options,
+		colorScheme: json.colorScheme === "dark" ? "dark" : "light",
+		foldLevel: json.foldLevel
+	};
+}
+async function loadNodeCanvas() {
+	try {
+		return await import("@markmap/canvas/node");
+	} catch {
+		return;
+	}
+}
+async function writeSvg({ markdown, file }, io) {
+	const images = file ? await inlineImages(inspect(markdown).urls, dirname(file), warnWith(io)) : /* @__PURE__ */ new Map();
+	const parsed = parse$1(markdown, { plugins: [remarkMath, remarkReplaceImages(images)] });
+	const { options, colorScheme, foldLevel } = documentOptions(parsed, io);
+	const canvas = await loadNodeCanvas();
+	if (!canvas) io.stderr("Without @napi-rs/canvas, text and image sizes are approximate\n");
+	const nodeImages = createImageContent({ loadSize: canvas && ((src) => canvas.loadNodeImage(src)) });
+	const result = await renderTreeAsync(parsed.root, {
+		...options,
+		plugins: options.plugins?.map((p) => p.name === nodeImages.name ? nodeImages : p),
+		measurer: canvas?.createNodeMeasurer() ?? approximateMeasurer,
+		folded: startFolded(parsed.root, foldLevel)
+	});
+	return toSVGString(result, { colorScheme });
+}
+async function writePng({ markdown, file }, io) {
+	const canvas = await loadNodeCanvas();
+	if (!canvas) throw new Error("--png needs @napi-rs/canvas, which is not installed");
+	const parsed = parse$1(markdown, { plugins: [remarkMath] });
+	const { options, colorScheme, foldLevel } = documentOptions(parsed, io);
+	return canvas.renderPNG(parsed.root, {
+		...options,
+		colorScheme,
+		baseDir: file && dirname(file),
+		folded: startFolded(parsed.root, foldLevel)
+	});
+}
+/** A file's real path, so links and other spellings of a name count as the same file. */
+var real = (path) => realpath(path).catch(() => void 0);
+/** What `output` would destroy, if it is the input or an image the input uses. */
+async function conflict({ markdown, file }, output) {
+	if (!file) return void 0;
+	const target = await real(output);
+	if (!target) return void 0;
+	if (target === await real(file)) return "the input";
+	const paths = inspect(markdown).urls.map((url) => localPath(url, dirname(file)));
+	for (const path of paths) if (path && target === await real(path)) return "an image the input uses";
+}
+async function version() {
+	const file = join(dirname(fileURLToPath(import.meta.url)), "../package.json");
+	return JSON.parse(await readFile(file, "utf8")).version;
+}
+/** Run the command. Returns the exit code. */
+async function main(argv, overrides = {}) {
+	const io = {
+		...defaultIo,
+		...overrides
+	};
+	let args;
+	try {
+		args = parseArgs({
+			args: [...argv],
+			allowPositionals: true,
+			options: {
+				output: {
+					type: "string",
+					short: "o"
+				},
+				svg: { type: "boolean" },
+				png: { type: "boolean" },
+				"no-open": { type: "boolean" },
+				"no-toolbar": { type: "boolean" },
+				help: {
+					type: "boolean",
+					short: "h"
+				},
+				version: {
+					type: "boolean",
+					short: "v"
+				}
+			}
+		});
+	} catch (error) {
+		io.stderr(`${error.message}\n\n${USAGE}`);
+		return 2;
+	}
+	const { values, positionals } = args;
+	if (values.help) {
+		io.stdout(USAGE);
+		return 0;
+	}
+	if (values.version) {
+		io.stdout(`${await version()}\n`);
+		return 0;
+	}
+	if (positionals.length !== 1 || values.svg && values.png) {
+		io.stderr(USAGE);
+		return 2;
+	}
+	const [input] = positionals;
+	const stdin = input === "-";
+	const extension = values.svg ? ".svg" : values.png ? ".png" : ".html";
+	const name = stdin ? "markmap" : parse(input).name;
+	const output = values.output ?? (stdin ? `${name}${extension}` : join(dirname(input), `${name}${extension}`));
+	try {
+		const source = stdin ? { markdown: await io.stdin() } : {
+			markdown: await readFile(input, "utf8"),
+			file: resolve(input)
+		};
+		const used = output === "-" ? void 0 : await conflict(source, output);
+		if (used) {
+			io.stderr(`Not overwriting ${output}: it is ${used}. Choose another name with -o.\n`);
+			return 1;
+		}
+		const data = values.svg ? await writeSvg(source, io) : values.png ? await writePng(source, io) : await writeHtml(source, !values["no-toolbar"], io);
+		if (output === "-") {
+			io.stdout(data);
+			return 0;
+		}
+		await mkdir(dirname(resolve(output)), { recursive: true });
+		await writeFile(output, data);
+		io.stderr(`Wrote ${output}\n`);
+		if (extname(output) === ".html" && !values.svg && !values.png && !values["no-open"]) io.open(resolve(output));
+		return 0;
+	} catch (error) {
+		const { code, path, message } = error;
+		io.stderr(`${code === "ENOENT" ? `No such file: ${path}` : message}\n`);
+		return 1;
+	}
+}
+// src/cli.ts
+process.exitCode = await main(process.argv.slice(2));

package/dist/inline-images.d.ts

@@ -0,0 +1,8 @@
+/** The file a URL in the Markdown points at, if it can point at one. */
+export declare function localPath(url: string, baseDir: string): string | undefined;
+/**
+ * Data URLs for local images, by the URL in the Markdown. Only files in `baseDir` are
+ * read: Markdown from someone else must not be able to pull other files into a page
+ * that gets shared. Anything skipped is reported and keeps its URL.
+ */
+export declare function inlineImages(urls: Iterable<string>, baseDir: string, warn: (message: string) => void): Promise<Map<string, string>>;

package/dist/main.d.ts

@@ -0,0 +1,11 @@
+/** The outside world, replaceable in tests. */
+export interface Io {
+    stdin(): Promise<string>;
+    stdout(data: string | Uint8Array): void;
+    stderr(text: string): void;
+    /** The bundled client script for a page. */
+    client(math: boolean): Promise<string>;
+    open(file: string): void;
+}
+/** Run the command. Returns the exit code. */
+export declare function main(argv: readonly string[], overrides?: Partial<Io>): Promise<number>;

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@markmap/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-next.0",
+  "description": "Turn Markdown into a map from the command line",
+  "homepage": "https://github.com/markmap/markmap#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markmap/markmap.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "markmap": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@markmap/canvas": "1.0.0-next.0",
+    "@markmap/core": "1.0.0-next.0",
+    "@markmap/page": "1.0.0-next.0",
+    "@markmap/parse": "1.0.0-next.0",
+    "@markmap/plugin-math": "1.0.0-next.0",
+    "@markmap/render": "1.0.0-next.0"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.4"
+  },
+  "optionalDependencies": {
+    "@napi-rs/canvas": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "build:types": "tsc -b",
+    "build:js": "vite build"
+  }
 }