@markset-lang/remark-markset 0.3.0

package/README.md

@@ -0,0 +1,75 @@
+# @markset-lang/remark-markset
+
+A [remark](https://github.com/remarkjs/remark) plugin that teaches an existing [unified](https://unifiedjs.com) pipeline to read [Markset](https://markset-lang.github.io/markset/).
+
+If you already run remark — in Astro, Next, Eleventy, Gatsby, a lint step, a script — this is how you get Markset's constructs without replacing any of it.
+
+```sh
+npm i @markset-lang/remark-markset
+```
+
+## Parsing
+
+```js
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkMarkset from "@markset-lang/remark-markset";
+
+const tree = await unified().use(remarkParse).use(remarkMarkset).parse(source);
+```
+
+Constructs become typed mdast nodes — `grid`, `card`, `callout`, `figure`, `tabs`, `steps`, `metrics`, `columns` — alongside `span` nodes for bracketed spans. Attribute specifiers and attribute lines are lowered onto `data.hProperties`, so any mdast-to-hast conversion picks them up with no further work.
+
+## Rendering to HTML
+
+The renderer's handlers are a separate package, so you only install them if you want them:
+
+```js
+import remarkRehype from "remark-rehype";
+import rehypeStringify from "rehype-stringify";
+import { marksetHandlers } from "@markset-lang/render-html";
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkMarkset)
+  .use(remarkRehype, { handlers: marksetHandlers() })
+  .use(rehypeStringify)
+  .process(source);
+```
+
+That pipeline produces the same HTML as the library's own `renderHtml`, and a test in this repository asserts it byte for byte.
+
+You will also want the stylesheet, which is `@markset-lang/render-html/css/markset.css`, or `markset css` from the CLI.
+
+## Diagnostics
+
+Markset has a closed vocabulary, so an unknown directive name is an error rather than silent passthrough (spec §3). Those arrive as ordinary vfile messages:
+
+```js
+for (const m of file.messages) {
+  console.log(m.fatal ? "error" : "warning", m.ruleId, m.reason, m.line, m.column);
+}
+```
+
+`ruleId` is the Markset diagnostic code (`DIRECTIVE_UNKNOWN_NAME`, `GRID_BAD_COLS`, …) and `source` is `"markset"`, so a pipeline that already reports vfile messages will report these without being taught anything.
+
+`fatal` is `true` for errors and `false` for warnings. A document with any error is invalid; warnings are not.
+
+## What it deliberately does not turn on
+
+This plugin adds Markset and nothing else, because your pipeline already has opinions:
+
+- **Tables** are GFM. Add `remark-gfm`.
+- **Frontmatter** is `remark-frontmatter`. Add it, and this plugin will read the `yaml` node it produces into the document's theme (spec §6). Without it, frontmatter is not parsed and nothing breaks.
+
+The reference `parseDocument` enables both because it is rendering whole documents; a plugin that did the same would be changing your pipeline behind your back.
+
+## Every CommonMark document is unaffected
+
+Markset is a strict superset: a document with no constructs in it parses and renders exactly as it did before you added the plugin. There is a test for precisely that, comparing the output with and without.
+
+## Peer dependencies
+
+`unified` and `remark-parse`, both version 11 or later — you already have them.
+
+MIT.

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A remark plugin that teaches an existing unified pipeline to read Markset.
+ *
+ * Markset's parser is already micromark and mdast underneath, so this is
+ * assembly rather than a second implementation: the same syntax extension, the
+ * same mdast compiler extension, and the same normalization and validation
+ * that `parseDocument` runs, arranged the way unified expects them.
+ *
+ * What it deliberately does not do is turn on anything the caller did not ask
+ * for. `parseDocument` enables GFM tables and YAML frontmatter because a
+ * Markset document may use both; a pipeline already has its own opinion about
+ * those, so add `remark-gfm` and `remark-frontmatter` if you want them. This
+ * plugin reads frontmatter when something else has parsed it into a `yaml`
+ * node, and ignores its absence.
+ */
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+declare const remarkMarkset: Plugin<[], Root, Root>;
+export default remarkMarkset;
+export { remarkMarkset };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAS,IAAI,EAAE,MAAM,OAAO,CAAC;AAMzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAoBtC,QAAA,MAAM,aAAa,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAoDzC,CAAC;eA4Da,aAAa;AAC5B,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,114 @@
+import { attachAttributeLines, markset, marksetFromMarkdown, normalizeConstructs, readFrontmatter, validateStructure, } from "@markset-lang/parser";
+/** Diagnostics collected during parsing, parked on the tree until the transform runs. */
+const CARRIED = "_marksetDiagnostics";
+const remarkMarkset = function remarkMarkset() {
+    const data = this.data();
+    data.micromarkExtensions ??= [];
+    data.fromMarkdownExtensions ??= [];
+    const micromarkExtensions = data.micromarkExtensions;
+    const fromMarkdownExtensions = data.fromMarkdownExtensions;
+    // The mdast extension reports into an array, and it is built once while
+    // parsing happens once per file. Handing it a long-lived array and reading
+    // that array later would mix two files' diagnostics together the first time
+    // anything processed two at once. A from-markdown transform runs
+    // synchronously at the end of the parse that produced the tree, so moving
+    // the diagnostics onto the tree there ties them to their own document and
+    // leaves the array empty for the next one.
+    const collected = [];
+    const extension = marksetFromMarkdown(collected);
+    const transforms = [
+        ...(extension.transforms ?? []),
+        (tree) => {
+            tree[CARRIED] = collected.splice(0);
+            return undefined;
+        },
+    ];
+    micromarkExtensions.push(markset());
+    fromMarkdownExtensions.push({ ...extension, transforms });
+    return (tree, file) => {
+        const source = String(file);
+        const carrier = tree;
+        const diagnostics = carrier[CARRIED] ?? [];
+        delete carrier[CARRIED];
+        const first = tree.children[0];
+        const meta = first?.type === "yaml" ? readFrontmatter(first, diagnostics) : null;
+        if (meta)
+            tree.frontmatter = meta;
+        attachAttributeLines(tree, source, diagnostics);
+        diagnostics.push(...validateStructure(tree, source));
+        normalizeConstructs(tree, source, diagnostics);
+        applyAttributes(tree);
+        diagnostics.sort((a, b) => a.start - b.start || a.end - b.end);
+        for (const d of diagnostics) {
+            const message = file.message(d.message, { place: pointAt(source, d.start), ruleId: d.code, source: "markset" });
+            // A vfile message is a warning unless it says otherwise, and Markset
+            // draws that line itself: a document with an error is invalid (§7), so
+            // the two severities must not collapse into one here.
+            message.fatal = d.severity === "error";
+        }
+        return undefined;
+    };
+};
+/**
+ * Node types whose own to-hast handler reads `attributes` itself, so writing
+ * hProperties for them would say the same thing twice. The list is the one in
+ * render-html; a test renders the same document both ways and fails if the two
+ * paths stop agreeing, which is what keeps this copy honest.
+ */
+const HANDLED = new Set([
+    "callout",
+    "card",
+    "grid",
+    "columns",
+    "column",
+    "tabs",
+    "tab",
+    "steps",
+    "metrics",
+    "figure",
+    "span",
+    "directive",
+    "separator",
+]);
+/**
+ * Lower §2.1 and §2.5 attributes onto `data.hProperties`, which is how mdast
+ * carries them to any hast conversion. Doing it here rather than inside a
+ * renderer is what makes an attribute line work with plain `remark-rehype`,
+ * and with anything else downstream that reads mdast.
+ */
+function applyAttributes(tree) {
+    const visit = (node) => {
+        const attributes = node.attributes;
+        if (attributes && !HANDLED.has(node.type)) {
+            const properties = {};
+            if (attributes.id)
+                properties.id = attributes.id;
+            if (attributes.classes.length)
+                properties.className = attributes.classes;
+            for (const [key, value] of Object.entries(attributes.attrs))
+                properties[`data-${key}`] = value;
+            node.data = {
+                ...node.data,
+                hProperties: { ...node.data?.hProperties, ...properties },
+            };
+        }
+        if ("children" in node)
+            for (const child of node.children)
+                visit(child);
+    };
+    visit(tree);
+}
+function pointAt(source, offset) {
+    let line = 1;
+    let lineStart = 0;
+    for (let i = 0; i < offset && i < source.length; i++) {
+        if (source[i] === "\n") {
+            line++;
+            lineStart = i + 1;
+        }
+    }
+    return { line, column: offset - lineStart + 1, offset };
+}
+export default remarkMarkset;
+export { remarkMarkset };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@markset-lang/remark-markset",
+  "version": "0.3.0",
+  "description": "remark plugin: parse Markset constructs in an existing unified pipeline.",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/markset-lang/markset.git",
+    "directory": "packages/remark-markset"
+  },
+  "homepage": "https://markset-lang.github.io/markset/",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "remark",
+    "remark-plugin",
+    "unified",
+    "mdast",
+    "markset"
+  ],
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "markset-source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@markset-lang/parser": "^0.3.0"
+  },
+  "peerDependencies": {
+    "remark-parse": ">=11",
+    "unified": ">=11"
+  }
+}

package/src/index.ts

@@ -0,0 +1,155 @@
+/**
+ * A remark plugin that teaches an existing unified pipeline to read Markset.
+ *
+ * Markset's parser is already micromark and mdast underneath, so this is
+ * assembly rather than a second implementation: the same syntax extension, the
+ * same mdast compiler extension, and the same normalization and validation
+ * that `parseDocument` runs, arranged the way unified expects them.
+ *
+ * What it deliberately does not do is turn on anything the caller did not ask
+ * for. `parseDocument` enables GFM tables and YAML frontmatter because a
+ * Markset document may use both; a pipeline already has its own opinion about
+ * those, so add `remark-gfm` and `remark-frontmatter` if you want them. This
+ * plugin reads frontmatter when something else has parsed it into a `yaml`
+ * node, and ignores its absence.
+ */
+import type { Nodes, Root } from "mdast";
+// For the type augmentation alone: remark-parse is what declares
+// micromarkExtensions and fromMarkdownExtensions on unified's Data. Every
+// remark plugin that registers a syntax extension does this, remark-gfm
+// included. Nothing is imported at runtime.
+import type {} from "remark-parse";
+import type { Plugin } from "unified";
+import type { VFile } from "vfile";
+import {
+  type Attributes,
+  attachAttributeLines,
+  markset,
+  marksetFromMarkdown,
+  normalizeConstructs,
+  readFrontmatter,
+  validateStructure,
+  type Diagnostic,
+} from "@markset-lang/parser";
+
+/** Diagnostics collected during parsing, parked on the tree until the transform runs. */
+const CARRIED = "_marksetDiagnostics";
+
+interface Carrier {
+  [CARRIED]?: Diagnostic[];
+}
+
+const remarkMarkset: Plugin<[], Root, Root> = function remarkMarkset() {
+  const data = this.data();
+  data.micromarkExtensions ??= [];
+  data.fromMarkdownExtensions ??= [];
+  const micromarkExtensions = data.micromarkExtensions;
+  const fromMarkdownExtensions = data.fromMarkdownExtensions;
+
+  // The mdast extension reports into an array, and it is built once while
+  // parsing happens once per file. Handing it a long-lived array and reading
+  // that array later would mix two files' diagnostics together the first time
+  // anything processed two at once. A from-markdown transform runs
+  // synchronously at the end of the parse that produced the tree, so moving
+  // the diagnostics onto the tree there ties them to their own document and
+  // leaves the array empty for the next one.
+  const collected: Diagnostic[] = [];
+  const extension = marksetFromMarkdown(collected);
+  const transforms = [
+    ...(extension.transforms ?? []),
+    (tree: Root): undefined => {
+      (tree as Root & Carrier)[CARRIED] = collected.splice(0);
+      return undefined;
+    },
+  ];
+
+  micromarkExtensions.push(markset());
+  fromMarkdownExtensions.push({ ...extension, transforms });
+
+  return (tree: Root, file: VFile): undefined => {
+    const source = String(file);
+    const carrier = tree as Root & Carrier;
+    const diagnostics = carrier[CARRIED] ?? [];
+    delete carrier[CARRIED];
+
+    const first = tree.children[0];
+    const meta = first?.type === "yaml" ? readFrontmatter(first, diagnostics) : null;
+    if (meta) tree.frontmatter = meta;
+
+    attachAttributeLines(tree, source, diagnostics);
+    diagnostics.push(...validateStructure(tree, source));
+    normalizeConstructs(tree, source, diagnostics);
+    applyAttributes(tree);
+    diagnostics.sort((a, b) => a.start - b.start || a.end - b.end);
+
+    for (const d of diagnostics) {
+      const message = file.message(d.message, { place: pointAt(source, d.start), ruleId: d.code, source: "markset" });
+      // A vfile message is a warning unless it says otherwise, and Markset
+      // draws that line itself: a document with an error is invalid (§7), so
+      // the two severities must not collapse into one here.
+      message.fatal = d.severity === "error";
+    }
+    return undefined;
+  };
+};
+
+/**
+ * Node types whose own to-hast handler reads `attributes` itself, so writing
+ * hProperties for them would say the same thing twice. The list is the one in
+ * render-html; a test renders the same document both ways and fails if the two
+ * paths stop agreeing, which is what keeps this copy honest.
+ */
+const HANDLED = new Set([
+  "callout",
+  "card",
+  "grid",
+  "columns",
+  "column",
+  "tabs",
+  "tab",
+  "steps",
+  "metrics",
+  "figure",
+  "span",
+  "directive",
+  "separator",
+]);
+
+/**
+ * Lower §2.1 and §2.5 attributes onto `data.hProperties`, which is how mdast
+ * carries them to any hast conversion. Doing it here rather than inside a
+ * renderer is what makes an attribute line work with plain `remark-rehype`,
+ * and with anything else downstream that reads mdast.
+ */
+function applyAttributes(tree: Root): void {
+  const visit = (node: Nodes): void => {
+    const attributes = (node as { attributes?: Attributes }).attributes;
+    if (attributes && !HANDLED.has(node.type)) {
+      const properties: Record<string, string | string[]> = {};
+      if (attributes.id) properties.id = attributes.id;
+      if (attributes.classes.length) properties.className = attributes.classes;
+      for (const [key, value] of Object.entries(attributes.attrs)) properties[`data-${key}`] = value;
+      node.data = {
+        ...node.data,
+        hProperties: { ...(node.data as { hProperties?: object } | undefined)?.hProperties, ...properties },
+      };
+    }
+    if ("children" in node) for (const child of node.children) visit(child as Nodes);
+  };
+  visit(tree);
+}
+
+function pointAt(source: string, offset: number): { line: number; column: number; offset: number } {
+  let line = 1;
+  let lineStart = 0;
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source[i] === "\n") {
+      line++;
+      lineStart = i + 1;
+    }
+  }
+  return { line, column: offset - lineStart + 1, offset };
+}
+
+export default remarkMarkset;
+export { remarkMarkset };