comment-block-transformer 0.5.7 → 0.7.0

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [0.7.0](https://github.com/DavidWells/markdown-magic/compare/comment-block-transformer@0.6.1...comment-block-transformer@0.7.0) (2026-01-19)
+
+
+### Features
+
+* **block-transformer:** add normalizeBlankLines option and utility ([bde5038](https://github.com/DavidWells/markdown-magic/commit/bde50389800da417787c6c4aae8165dd9f7de0b5))
+
+
+
+
+
+## [0.6.1](https://github.com/DavidWells/markdown-magic/compare/comment-block-transformer@0.6.0...comment-block-transformer@0.6.1) (2026-01-19)
+
+**Note:** Version bump only for package comment-block-transformer
+
+
+
+
+
+# [0.6.0](https://github.com/DavidWells/markdown-magic/compare/comment-block-transformer@0.5.7...comment-block-transformer@0.6.0) (2026-01-19)
+
+
+### Features
+
+* **block-transformer:** add forceRemoveComments option ([7503338](https://github.com/DavidWells/markdown-magic/commit/7503338ee182a935b04e7162276fd3df072b59a9))
+
+
+
+
+
 ## [0.5.7](https://github.com/DavidWells/markdown-magic/compare/comment-block-transformer@0.5.6...comment-block-transformer@0.5.7) (2026-01-19)
 
 **Note:** Version bump only for package comment-block-transformer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comment-block-transformer",
-  "version": "0.5.7",
+  "version": "0.7.0",
   "description": "Transform markdown blocks based on configured transforms",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -25,5 +25,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2bef6eae03b732f55673524c1e928ecff8b2c86c"
+  "gitHead": "37ed26b98df488f005d9ef91ecd8cd9649c5c067"
 }

package/src/index.js

@@ -66,6 +66,8 @@ const CLOSE_WORD = '/block'
  * @property {Array<Middleware>}  [beforeMiddleware=[]] - Middleware functions change inner block content before transforms.
  * @property {Array<Middleware>}  [afterMiddleware=[]] - Middleware functions change inner block content after transforms.
  * @property {boolean} [removeComments=false] - Remove comments from the processed contents.
+ * @property {boolean} [forceRemoveComments=false] - Force remove comments even when srcPath === outputPath, strips comments directly in updatedContents.
+ * @property {boolean} [normalizeBlankLines=false] - Collapse multiple consecutive blank lines to single blank line (preserves blank lines in code blocks).
  * @property {string} [srcPath] - The source path.
  * @property {string} [outputPath] - The output path.
  * @property {import('comment-block-parser').CustomPatterns} [customPatterns] - Custom regex patterns for open and close tags.
@@ -103,6 +105,8 @@ async function blockTransformer(inputText, config) {
     beforeMiddleware = [],
     afterMiddleware = [],
     removeComments = false,
+    forceRemoveComments = false,
+    normalizeBlankLines: normalizeBlankLinesOpt = false,
     customPatterns
   } = opts
   // Don't default close - let undefined pass through to enable pattern mode in block-parser
@@ -285,15 +289,22 @@ async function blockTransformer(inputText, config) {
 
   const isNewPath = srcPath !== outputPath
 
-  if (removeComments && !isNewPath) {
+  if (removeComments && !isNewPath && !forceRemoveComments) {
     throw new Error('"removeComments" can only be used if "outputPath" option is set. Otherwise this will break doc generation.')
   }
 
-  const stripComments = isNewPath && removeComments
+  const stripComments = (isNewPath && removeComments) || forceRemoveComments
 
+  let finalContents = updatedContents
+  if (forceRemoveComments && openPattern && closePattern) {
+    finalContents = finalContents.replace(openPattern, '').replace(closePattern, '')
+  }
+  if (normalizeBlankLinesOpt) {
+    finalContents = normalizeBlankLines(finalContents)
+  }
 
   // console.log('inputText', inputText)
-  // console.log('updatedContents', updatedContents) 
+  // console.log('updatedContents', updatedContents)
   return {
     isChanged: inputText !== updatedContents,
     isNewPath,
@@ -303,12 +314,11 @@ async function blockTransformer(inputText, config) {
     transforms: transformsToRun,
     missingTransforms,
     originalContents: inputText,
-    updatedContents,
+    updatedContents: finalContents,
     patterns: regexInfo,
   }
 }
 
-
 /** @typedef {BlockData & { sourceLocation?: string, transform?: string }} BlockDataExtended */
 
 function getDetails({
@@ -439,6 +449,43 @@ function getCodeLocation(srcPath, line, column = '0') {
   return `${srcPath}:${line}:${column}`
 }
 
+/**
+ * Normalize blank lines in content, collapsing multiple consecutive blank lines to a single one.
+ * Preserves blank lines inside fenced code blocks (``` or ~~~).
+ * @param {string} content - The content to normalize
+ * @returns {string} Content with normalized blank lines
+ */
+function normalizeBlankLines(content) {
+  if (!content) return content
+
+  const lines = content.split('\n')
+  const result = []
+  let inCodeBlock = false
+  let consecutiveBlanks = 0
+
+  for (const line of lines) {
+    // Check for code fence (``` or ~~~), possibly with language specifier, possibly indented
+    if (/^\s*(`{3,}|~{3,})/.test(line)) {
+      inCodeBlock = !inCodeBlock
+      consecutiveBlanks = 0
+      result.push(line)
+      continue
+    }
+
+    if (line.trim() === '' && !inCodeBlock) {
+      consecutiveBlanks++
+      if (consecutiveBlanks <= 1) {
+        result.push(line)
+      }
+    } else {
+      consecutiveBlanks = 0
+      result.push(line)
+    }
+  }
+
+  return result.join('\n')
+}
+
 if (require.main === module) {
   const yaml = `
   - name: Run tests two
@@ -451,4 +498,5 @@ if (require.main === module) {
 module.exports = {
   blockTransformer,
   indentString,
+  normalizeBlankLines,
 } 

package/test/error-handling.test.js

@@ -248,4 +248,93 @@ original content
   assert.ok(result.updatedContents.includes('original content'))
 })
 
+test('forceRemoveComments bypasses safety check and strips comments from updatedContents', async () => {
+  const text = `
+<!-- block test -->
+content
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    srcPath: '/same/path.md',
+    outputPath: '/same/path.md',
+    forceRemoveComments: true,
+    transforms: {
+      test: (api) => 'transformed'
+    }
+  })
+
+  assert.is(result.stripComments, true)
+  assert.not.ok(result.updatedContents.includes('<!-- block'))
+  assert.not.ok(result.updatedContents.includes('<!-- /block'))
+  assert.ok(result.updatedContents.includes('transformed'))
+})
+
+test('forceRemoveComments works without outputPath', async () => {
+  const text = `
+<!-- block test -->
+content
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    forceRemoveComments: true,
+    transforms: {
+      test: (api) => 'transformed'
+    }
+  })
+
+  assert.is(result.stripComments, true)
+  assert.not.ok(result.updatedContents.includes('<!-- block'))
+  assert.not.ok(result.updatedContents.includes('<!-- /block'))
+  assert.ok(result.updatedContents.includes('transformed'))
+})
+
+test('normalizeBlankLines option collapses multiple blank lines', async () => {
+  const text = `## Section
+
+<!-- block test -->
+content
+<!-- /block -->
+
+<!-- block empty -->
+<!-- /block -->
+
+---`
+  const result = await blockTransformer(text, {
+    forceRemoveComments: true,
+    normalizeBlankLines: true,
+    transforms: {
+      test: () => 'transformed',
+      empty: () => ''
+    }
+  })
+
+  // Should not have 2+ consecutive blank lines outside code blocks
+  assert.not.ok(result.updatedContents.includes('\n\n\n'))
+})
+
+test('normalizeBlankLines preserves blank lines in code blocks', async () => {
+  const text = `## Section
+
+<!-- block code -->
+\`\`\`bash
+line 1
+
+
+line 2
+\`\`\`
+<!-- /block -->
+
+---`
+  const result = await blockTransformer(text, {
+    forceRemoveComments: true,
+    normalizeBlankLines: true,
+    transforms: {
+      code: (api) => api.content
+    }
+  })
+
+  // Code block should preserve its blank lines
+  assert.ok(result.updatedContents.includes('line 1\n\n\nline 2'))
+})
+
 test.run()

package/test/normalize-blank-lines.test.js

@@ -0,0 +1,181 @@
+// Tests for normalizeBlankLines utility
+
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { normalizeBlankLines } = require('../src')
+
+test('collapses multiple blank lines to single blank line', () => {
+  const input = `line 1
+
+
+line 2`
+  const result = normalizeBlankLines(input)
+  assert.is(result, `line 1
+
+line 2`)
+})
+
+test('preserves single blank lines', () => {
+  const input = `line 1
+
+line 2`
+  const result = normalizeBlankLines(input)
+  assert.is(result, input)
+})
+
+test('collapses 3+ blank lines to single', () => {
+  const input = `line 1
+
+
+
+
+line 2`
+  const result = normalizeBlankLines(input)
+  assert.is(result, `line 1
+
+line 2`)
+})
+
+test('preserves blank lines inside fenced code blocks (```)', () => {
+  const input = `before
+
+\`\`\`bash
+line 1
+
+
+line 2
+\`\`\`
+
+after`
+  const result = normalizeBlankLines(input)
+  assert.is(result, input)
+})
+
+test('preserves blank lines inside fenced code blocks (~~~)', () => {
+  const input = `before
+
+~~~js
+line 1
+
+
+line 2
+~~~
+
+after`
+  const result = normalizeBlankLines(input)
+  assert.is(result, input)
+})
+
+test('handles multiple code blocks', () => {
+  const input = `start
+
+
+\`\`\`
+code 1
+
+
+more code
+\`\`\`
+
+
+middle
+
+
+\`\`\`
+code 2
+
+
+more
+\`\`\`
+
+
+end`
+  const expected = `start
+
+\`\`\`
+code 1
+
+
+more code
+\`\`\`
+
+middle
+
+\`\`\`
+code 2
+
+
+more
+\`\`\`
+
+end`
+  const result = normalizeBlankLines(input)
+  assert.is(result, expected)
+})
+
+test('handles code block with language specifier', () => {
+  const input = `text
+
+
+\`\`\`javascript
+const x = 1
+
+
+const y = 2
+\`\`\`
+
+
+more text`
+  const expected = `text
+
+\`\`\`javascript
+const x = 1
+
+
+const y = 2
+\`\`\`
+
+more text`
+  const result = normalizeBlankLines(input)
+  assert.is(result, expected)
+})
+
+test('handles empty input', () => {
+  assert.is(normalizeBlankLines(''), '')
+})
+
+test('handles input with no blank lines', () => {
+  const input = `line 1
+line 2
+line 3`
+  assert.is(normalizeBlankLines(input), input)
+})
+
+test('handles indented code fences', () => {
+  const input = `text
+
+
+  \`\`\`
+  code
+
+
+  more
+  \`\`\`
+
+
+end`
+  const expected = `text
+
+  \`\`\`
+  code
+
+
+  more
+  \`\`\`
+
+end`
+  const result = normalizeBlankLines(input)
+  assert.is(result, expected)
+})
+
+test.run()