remark-break-line 0.0.1

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./lib/index.js";

package/index.js

@@ -0,0 +1 @@
+export {default} from './lib/index.js'

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Turn gemoji shortcodes (`:+1:`) into emoji (`👍`).
+ *
+ * @returns
+ *   Transform.
+ */
+export default function remarkBreakLongLines({ maxLineLength }?: {
+    maxLineLength?: number | undefined;
+}): (tree: Root) => undefined;
+export type Root = import("mdast").Root;

package/lib/index.js

@@ -0,0 +1,235 @@
+/**
+ * @typedef {import('mdast').Root} Root
+ */
+
+import { assert } from 'console'
+import { visit } from 'unist-util-visit'
+
+/**
+ *
+ * @param {string} string_
+ * @param {number} index
+ * @param {string} replacement
+ * @returns
+ */
+function replaceAt(string_, index, replacement) {
+  return (
+    string_.slice(0, Math.max(0, index)) +
+    replacement +
+    string_.slice(Math.max(0, index + replacement.length))
+  )
+}
+
+const elementSize = {
+  text: 0,
+  strong: 2,
+  emphasis: 2,
+  delete: 2
+}
+
+/**
+ * Turn gemoji shortcodes (`:+1:`) into emoji (`👍`).
+ *
+ * @returns
+ *   Transform.
+ */
+export default function remarkBreakLongLines({ maxLineLength = 80 } = {}) {
+  /**
+   * Transform.
+   *
+   * @param {Root} tree
+   *   Tree.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree) {
+    visit(tree, function (node) {
+      if (node.type === 'paragraph') {
+        let currentLine = 0
+        /**
+         *
+         * @param {typeof node.children[number]} n
+         * @returns {{type:'nothing'}|{type:'break-before'}|{type:'split', replaceBy:[typeof node.children[number],typeof node.children[number]]}}
+         */
+        const walk = (n, /** @type {(typeof node.children[number]['type'])[]} */ path) => {
+          if (n.type === 'text' && n.value.length > 0) {
+            let lastIndex = n.value[0] === '\n' ? 0 : -1
+
+
+
+
+            {   // @ts-ignore
+              const additionalCharacters = path.map(p => (elementSize[p] ?? 0) * 2).reduce((p, c) => p + c, 0);
+              if (currentLine + additionalCharacters >= maxLineLength) {
+                if (path.some(x => x != 'text')) {
+                  // we need to split the node
+                  const current = path[path.length - 1];
+                  assert(current === 'text');
+
+                  return {
+                    type: 'break-before',
+                  };
+
+
+
+                } else {
+                  n.value = '\n' + n.value
+                  currentLine = 0
+                }
+              }
+            }
+
+
+            for (let i = 0; i < n.value.length; i++) {
+              const element = n.value[i]
+              if (element === '\n') {
+                // @ts-ignore
+                const additionalCharacters = path.map(p => (elementSize[p] ?? 0) * 2).reduce((p, c) => p + c, 0);
+                if (currentLine + additionalCharacters >= maxLineLength) {
+                  if (path.some(x => x != 'text')) {
+                    // we need to split the node
+                    const current = path[path.length - 1];
+                    assert(current === 'text');
+
+                    return {
+                      type: 'split',
+                      replaceBy: [{ type: 'text', value: n.value.substring(0, lastIndex) }, { type: 'text', value: n.value.substring(lastIndex + 1) }]
+                    };
+
+
+
+                  } else {
+                    if (lastIndex === -1) {
+                      // We need to increase i because we increase the text
+                      i++
+                      n.value = '\n' + n.value
+                    } else {
+                      n.value = replaceAt(n.value, lastIndex, '\n')
+                    }
+                    currentLine = i - lastIndex
+                  }
+                }
+
+
+                currentLine = 0
+              } else if (element === ' ') {
+                // @ts-ignore
+                const additionalCharacters = path.map(p => (elementSize[p] ?? 0) * 2).reduce((p, c) => p + c, 0);
+                if (currentLine + additionalCharacters >= maxLineLength) {
+                  if (path.some(x => x != 'text')) {
+                    // we need to split the node
+                    const current = path[path.length - 1];
+                    assert(current === 'text');
+
+
+                    if (lastIndex === -1) {
+                      return { type: 'break-before' };
+                    }
+
+                    return {
+                      type: 'split',
+                      replaceBy: [{ type: 'text', value: n.value.substring(0, lastIndex) }, { type: 'text', value: n.value.substring(lastIndex + 1) }]
+                    };
+
+
+
+                  } else {
+                    if (lastIndex === -1) {
+                      // We need to increase i because we increase the text
+                      i++
+                      n.value = '\n' + n.value
+                    } else {
+                      n.value = replaceAt(n.value, lastIndex, '\n')
+                    }
+                    currentLine = i - lastIndex
+                  }
+                }
+
+                currentLine++
+
+                lastIndex = i
+              } else {
+                currentLine++
+              }
+            }
+
+            {
+              // @ts-ignore
+              const additionalCharacters = path.map(p => (elementSize[p] ?? 0) * 2).reduce((p, c) => p + c, 0);
+              if (currentLine + additionalCharacters >= maxLineLength) {
+                if (path.some(x => x != 'text')) {
+                  // we need to split the node
+                  const current = path[path.length - 1];
+                  assert(current === 'text');
+
+                  return {
+                    type: 'split',
+                    replaceBy: [{ type: 'text', value: n.value.substring(0, lastIndex) }, { type: 'text', value: n.value.substring(lastIndex + 1) }]
+                  };
+
+
+
+                } else {
+                  if (lastIndex === -1) {
+                    // We need to increase i because we increase the text
+
+                    n.value = '\n' + n.value
+                  } else {
+                    n.value = replaceAt(n.value, lastIndex, '\n')
+                  }
+
+                }
+              }
+            }
+          } else if ('children' in n) {
+            for (let i = 0; i < n.children.length; i++) {
+              const element = n.children[i]
+              if (element.type in elementSize) {
+                const result = walk(element, [...path, element.type]);
+                if (result.type === 'split') {
+                  /**
+                   * @type {any}
+                  */
+                  const current = path[path.length - 1];
+
+                  return {
+                    type: 'split',
+                    replaceBy: [{ type: current, children: [...n.children.slice(0, i), result.replaceBy[0]] },
+                    { type: current, children: [result.replaceBy[1], ...n.children.slice(i + 1)] }]
+                  };
+                } else if (result.type === 'break-before') {
+                  return {
+                    type: 'break-before',
+                  };
+                }
+              }
+            }
+          }
+
+          return { type: 'nothing' };
+        }
+
+        for (let i = 0; i < node.children.length; i++) {
+          const element = node.children[i]
+          const result = walk(element, [element.type])
+
+          if (result.type == 'split') {
+            currentLine = 0
+            node.children.splice(i, 1, result.replaceBy[0], { type: 'text', value: '\n' }, result.replaceBy[1])
+          } else if (result.type == 'break-before') {
+            currentLine = 0
+            node.children.splice(i, 0, { type: 'text', value: '\n' })
+            if (i > 0) {
+              const prev = node.children[i - 1];
+              if (prev.type === 'text') {
+                prev.value = prev.value.trimEnd();
+              }
+            }
+          }
+        }
+      }
+
+    })
+    console.log(JSON.stringify(tree));
+  }
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "remark-break-line",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "",
+  "keywords": [
+    "markdown",
+    "plugin",
+    "remark",
+    "remark-plugin",
+    "unified"
+  ],
+  "author": "",
+  "license": "ISC",
+  "exports": "./index.js",
+  "files": [
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "dependencies": {
+    "@types/mdast": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "c8": "^8.0.0",
+    "prettier": "^3.0.0",
+    "remark": "^15.0.0",
+    "remark-cli": "^12.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.56.0"
+  },
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark . --frail --output --quiet && prettier . --log-level warn --write && xo --fix",
+    "prepack": "npm run build && npm run format",
+    "test": "npm run build && npm run format && npm run test-api",
+    "test-api": "node --conditions development test/index.js",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "singleQuote": true,
+    "semi": false,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "test/**/*.js"
+        ],
+        "rules": {
+          "no-await-in-loop": "off"
+        }
+      }
+    ],
+    "prettier": true
+  }
+}