@webpro/remark-wrap-prose 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License (ISC)
+
+Copyright 2026 Lars Kappert
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# remark-wrap-prose
+
+Wrap prose to a maximum line width when serializing markdown.
+
+Only paragraphs are reflowed. Indentation from lists and block quotes is handled
+by the default serializer, so wrapping stays within the limit at every nesting
+level. Tables, code, and other non-prose blocks are left untouched. Wide CJK
+characters and emoji count as two columns. Words wider than the limit are never
+broken mid-word.
+
+## Install
+
+```sh
+pnpm add @webpro/remark-wrap-prose
+```
+
+## Use
+
+```js
+import { remark } from "remark";
+import remarkWrapProse from "@webpro/remark-wrap-prose";
+
+const file = await remark().use(remarkWrapProse, { width: 80 }).process(input);
+```
+
+## Example
+
+### Input
+
+```markdown
+Custom elements are registered under a tag name. When such a class isn't referenced elsewhere, it would be reported as unused. Instead, the registration is recognized.
+
+- A list item with enough words in it to require wrapping across more than one single line at the configured width.
+```
+
+### Output
+
+```markdown
+Custom elements are registered under a tag name. When such a class isn't
+referenced elsewhere, it would be reported as unused. Instead, the registration
+is recognized.
+
+- A list item with enough words in it to require wrapping across more than one
+  single line at the configured width.
+```
+
+## Width
+
+The wrap width is resolved in order:
+
+1. The `width` option.
+2. `max_line_length` from the nearest [`.editorconfig`][editorconfig].
+3. `80`.
+
+Prettier maps `max_line_length` to `printWidth`, so a single `.editorconfig`
+entry drives both this plugin's prose wrapping and Prettier's code/table
+wrapping.
+
+[editorconfig]: https://editorconfig.org

package/editorconfig.js

@@ -0,0 +1,123 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/**
+ * Read `max_line_length` that applies to a markdown file in `dir`, from the
+ * nearest `.editorconfig` files (walking up to a `root = true` file). A focused
+ * reader: it only needs this one property and the glob features that occur in
+ * practice (`*`, `**`, `?`, `[set]`, `{a,b}`). Prettier maps the same key to
+ * `printWidth`, so one setting drives both prose and code wrapping.
+ *
+ * @param {string} [dir]
+ * @returns {number | undefined}
+ */
+export function editorConfigWidth(dir = process.cwd()) {
+  try {
+    const configs = [];
+    for (let current = dir; ; ) {
+      let text;
+      try {
+        text = readFileSync(join(current, '.editorconfig'), 'utf8');
+      } catch {}
+      if (text !== undefined) {
+        const config = parseEditorConfig(text);
+        configs.push(config);
+        if (config.root) break;
+      }
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+
+    // Nearest config wins, so apply the farthest first and let nearer override.
+    let value;
+    for (const config of configs.reverse()) {
+      for (const [pattern, max] of config.sections) {
+        if (max !== undefined && pattern.test('x.md')) value = max;
+      }
+    }
+
+    const width = Number(value);
+    return Number.isInteger(width) && width > 0 ? width : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * @param {string} text
+ * @returns {{ root: boolean, sections: Array<[RegExp, string | undefined]> }}
+ */
+function parseEditorConfig(text) {
+  let root = false;
+  /** @type {Array<[RegExp, Record<string, string>]>} */
+  const sections = [];
+  let props;
+
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === '' || line.startsWith('#') || line.startsWith(';')) continue;
+
+    if (line.startsWith('[') && line.endsWith(']')) {
+      props = {};
+      sections.push([globToRegExp(line.slice(1, -1)), props]);
+      continue;
+    }
+
+    const eq = line.indexOf('=');
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim().toLowerCase();
+    const val = line.slice(eq + 1).trim();
+    if (props) props[key] = val;
+    else if (key === 'root') root = val.toLowerCase() === 'true';
+  }
+
+  return {
+    root,
+    sections: sections.map(([re, p]) => [re, p.max_line_length])
+  };
+}
+
+/**
+ * Compile an EditorConfig section glob to an anchored RegExp.
+ *
+ * @param {string} glob
+ * @returns {RegExp}
+ */
+function globToRegExp(glob) {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === '*') {
+      if (glob[i + 1] === '*') {
+        re += '.*';
+        i++;
+      } else {
+        re += '[^/]*';
+      }
+    } else if (c === '?') {
+      re += '[^/]';
+    } else if (c === '{') {
+      const close = glob.indexOf('}', i);
+      if (close === -1) {
+        re += '\\{';
+      } else {
+        const alts = glob.slice(i + 1, close).split(',');
+        re += '(?:' + alts.map(a => globToRegExp(a).source.slice(1, -1)).join('|') + ')';
+        i = close;
+      }
+    } else if (c === '[') {
+      const close = glob.indexOf(']', i + 1);
+      if (close === -1) {
+        re += '\\[';
+      } else {
+        const set = glob.slice(i + 1, close);
+        re += '[' + (set[0] === '!' ? '^' + set.slice(1) : set) + ']';
+        i = close;
+      }
+    } else {
+      re += c.replace(/[.+^${}()|\\]/g, '\\$&');
+    }
+  }
+  return new RegExp('^' + re + '$');
+}

package/index.d.ts

@@ -0,0 +1,14 @@
+export interface Options {
+  /**
+   * Maximum display width (columns) per line. Overrides `.editorconfig`.
+   *
+   * Resolved in order: this option, then `max_line_length` from
+   * `.editorconfig`, then `80`.
+   */
+  width?: number;
+}
+
+/**
+ * Wrap prose to a maximum line width when serializing back to markdown.
+ */
+export default function remarkWrapProse(options?: Options): undefined;

package/index.js

@@ -0,0 +1,108 @@
+import fastStringTruncatedWidth from 'fast-string-truncated-width';
+import { editorConfigWidth } from './editorconfig.js';
+
+const DEFAULT_WIDTH = 80;
+
+const widthOptions = {
+  tabWidth: 1,
+  emojiWidth: 2,
+  regularWidth: 1,
+  wideWidth: 2
+};
+
+/**
+ * Display width of a string, counting wide CJK characters and emoji as 2.
+ *
+ * @param {string} value
+ * @returns {number}
+ */
+function displayWidth(value) {
+  return fastStringTruncatedWidth(value, { limit: Infinity }, widthOptions)
+    .width;
+}
+
+// ASCII soft-wrap whitespace (space, tab, newline, form feed, vertical tab).
+// Unicode spaces (no-break U+00A0, narrow no-break U+202F, …) are intentional
+// content and are left untouched, so they survive reflow.
+const SOFT_WHITESPACE = /[ \t\n\r\f\v]+/;
+
+/**
+ * Greedily wrap words to a maximum display width, collapsing only ASCII
+ * soft-wrap whitespace. Words wider than the limit are kept intact (never
+ * broken mid-word).
+ *
+ * @param {string} text
+ * @param {number} width
+ * @returns {string}
+ */
+function fill(text, width) {
+  /** @type {Array<string>} */
+  const lines = [];
+  let line = '';
+  let lineWidth = 0;
+
+  for (const word of text.split(SOFT_WHITESPACE)) {
+    if (!word) continue;
+    const wordWidth = displayWidth(word);
+    if (line === '') {
+      line = word;
+      lineWidth = wordWidth;
+    } else if (lineWidth + 1 + wordWidth <= width) {
+      line += ' ' + word;
+      lineWidth += 1 + wordWidth;
+    } else {
+      lines.push(line);
+      line = word;
+      lineWidth = wordWidth;
+    }
+  }
+
+  if (line) lines.push(line);
+  return lines.join('\n');
+}
+
+/**
+ * Wrap prose to a maximum line width when serializing back to markdown.
+ *
+ * Only paragraphs are reflowed. Indentation from lists and block quotes is
+ * handled by the default serializer, so wrapping stays correct (and within
+ * width) at every nesting level. A leading GitHub alert marker (`[!NOTE]`,
+ * serialized from a `gfmAlert` node) is kept on its own line.
+ *
+ * Width is resolved in order: the `width` option, then `.editorconfig`'s
+ * `max_line_length`, then `80`.
+ *
+ * @this {import('unified').Processor}
+ * @param {object} [options]
+ * @param {number} [options.width]
+ *   Maximum display width (columns) per line. Overrides `.editorconfig`.
+ *   Defaults to `max_line_length` from `.editorconfig`, otherwise `80`.
+ */
+export default function remarkWrapProse(options = {}) {
+  const width = options.width ?? editorConfigWidth() ?? DEFAULT_WIDTH;
+
+  const data = this.data();
+  data.toMarkdownExtensions = data.toMarkdownExtensions || [];
+  data.toMarkdownExtensions.push({
+    handlers: {
+      paragraph(node, _parent, state, info) {
+        const exit = state.enter('paragraph');
+        const subexit = state.enter('phrasing');
+        const value = state.containerPhrasing(node, info);
+        subexit();
+        exit();
+
+        const available = Math.max(1, width - (info.lineShift || 0));
+
+        const first = node.children[0];
+        if (first?.type === 'gfmAlert') {
+          const marker = value.slice(0, first.value.length);
+          const body = fill(value.slice(first.value.length), available);
+          return body ? marker + '\n' + body : marker;
+        }
+
+        return fill(value, available);
+      }
+    }
+  });
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@webpro/remark-wrap-prose",
+  "version": "1.0.0",
+  "description": "Remark plugin to wrap prose to a maximum line width",
+  "keywords": [
+    "unified",
+    "remark",
+    "remark-plugin",
+    "plugin",
+    "markdown",
+    "prose",
+    "wrap",
+    "fill",
+    "reflow",
+    "width"
+  ],
+  "homepage": "https://github.com/webpro/remark-wrap-prose",
+  "bugs": "https://github.com/webpro/remark-wrap-prose/issues",
+  "repository": "github:webpro/remark-wrap-prose",
+  "license": "ISC",
+  "author": {
+    "name": "Lars Kappert",
+    "email": "lars@webpro.nl"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@11.5.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "editorconfig.js",
+    "index.d.ts"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "fast-string-truncated-width": "^3.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.4",
+    "remark": "^15.0.1",
+    "remark-directive": "^4.0.0"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}