comment-block-transformer 0.2.3 → 0.2.4

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.2.4](https://github.com/DavidWells/markdown-magic/compare/comment-block-transformer@0.2.3...comment-block-transformer@0.2.4) (2026-01-08)
+
+**Note:** Version bump only for package comment-block-transformer
+
+
+
+
+
 ## [0.2.3](https://github.com/DavidWells/markdown-magic/compare/comment-block-transformer@0.2.2...comment-block-transformer@0.2.3) (2025-12-30)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comment-block-transformer",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Transform markdown blocks based on configured transforms",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -15,7 +15,7 @@
     "release:major": "pnpm run build && pnpm version major && pnpm publish"
   },
   "dependencies": {
-    "comment-block-parser": "1.1.2"
+    "comment-block-parser": "1.1.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -25,5 +25,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7d81950b7a6d27d1192b1bc2d0f19d1d5ff0f321"
+  "gitHead": "966eb812a9044c8bcf7d5caf04a860dade0506af"
 }

package/test/error-handling.test.js

@@ -0,0 +1,251 @@
+// Tests for error handling in blockTransformer
+
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { blockTransformer } = require('../src')
+
+test('throws when removeComments is used without outputPath', async () => {
+  const text = `
+<!-- block test -->
+content
+<!-- /block -->
+`
+  try {
+    await blockTransformer(text, {
+      removeComments: true,
+      transforms: {
+        test: (api) => api.content
+      }
+    })
+    assert.unreachable('should have thrown')
+  } catch (e) {
+    assert.ok(e.message.includes('removeComments'))
+    assert.ok(e.message.includes('outputPath'))
+  }
+})
+
+test('removeComments works when outputPath differs from srcPath', async () => {
+  const text = `
+<!-- block test -->
+content
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    srcPath: '/input.md',
+    outputPath: '/output.md',
+    removeComments: true,
+    transforms: {
+      test: (api) => api.content
+    }
+  })
+
+  assert.is(result.stripComments, true)
+  assert.is(result.isNewPath, true)
+})
+
+test('propagates parse errors from unbalanced tags', async () => {
+  const text = `
+<!-- block test -->
+content missing close tag
+`
+  try {
+    await blockTransformer(text, {
+      transforms: {
+        test: (api) => api.content
+      }
+    })
+    assert.unreachable('should have thrown')
+  } catch (e) {
+    assert.ok(e.message.includes('unbalanced') || e.message.includes('Fix content'))
+  }
+})
+
+test('includes srcPath in error message when available', async () => {
+  const text = `
+<!-- block test -->
+missing close tag
+`
+  try {
+    await blockTransformer(text, {
+      srcPath: '/path/to/file.md',
+      transforms: {
+        test: (api) => api.content
+      }
+    })
+    assert.unreachable('should have thrown')
+  } catch (e) {
+    assert.ok(e.message.includes('/path/to/file.md'))
+  }
+})
+
+test('handles transform returning number', async () => {
+  const text = `
+<!-- block numberTest -->
+original
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    transforms: {
+      numberTest: () => 42
+    }
+  })
+
+  assert.ok(result.updatedContents.includes('42'))
+})
+
+test('handles transform returning array', async () => {
+  const text = `
+<!-- block arrayTest -->
+original
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    transforms: {
+      arrayTest: () => ['item1', 'item2', 'item3']
+    }
+  })
+
+  assert.ok(result.updatedContents.includes('item1'))
+  assert.ok(result.updatedContents.includes('item2'))
+})
+
+test('handles transform returning object', async () => {
+  const text = `
+<!-- block objectTest -->
+original
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    transforms: {
+      objectTest: () => ({ key: 'value', nested: { a: 1 } })
+    }
+  })
+
+  assert.ok(result.updatedContents.includes('key'))
+  assert.ok(result.updatedContents.includes('value'))
+})
+
+test('handles async transform that throws', async () => {
+  const text = `
+<!-- block failingTransform -->
+content
+<!-- /block -->
+`
+  try {
+    await blockTransformer(text, {
+      transforms: {
+        failingTransform: async () => {
+          throw new Error('Transform failed!')
+        }
+      }
+    })
+    assert.unreachable('should have thrown')
+  } catch (e) {
+    assert.ok(e.message.includes('Transform failed!'))
+  }
+})
+
+test('handles sync transform that throws', async () => {
+  const text = `
+<!-- block syncFail -->
+content
+<!-- /block -->
+`
+  try {
+    await blockTransformer(text, {
+      transforms: {
+        syncFail: () => {
+          throw new Error('Sync transform error')
+        }
+      }
+    })
+    assert.unreachable('should have thrown')
+  } catch (e) {
+    assert.ok(e.message.includes('Sync transform error'))
+  }
+})
+
+test('handles null config gracefully', async () => {
+  const text = `
+<!-- block test -->
+content
+<!-- /block -->
+`
+  // Should not throw, just return unchanged content
+  const result = await blockTransformer(text, null)
+  assert.ok(result.missingTransforms.length > 0)
+})
+
+test('handles empty transforms object', async () => {
+  const text = `
+<!-- block unknownTransform -->
+content
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    transforms: {}
+  })
+
+  assert.is(result.missingTransforms.length, 1)
+  assert.is(result.missingTransforms[0].transform, 'unknownTransform')
+})
+
+test('handles middleware that throws', async () => {
+  const text = `
+<!-- block test -->
+content
+<!-- /block -->
+`
+  try {
+    await blockTransformer(text, {
+      transforms: {
+        test: (api) => api.content
+      },
+      beforeMiddleware: [
+        {
+          name: 'failingMiddleware',
+          transform: () => {
+            throw new Error('Middleware error')
+          }
+        }
+      ]
+    })
+    assert.unreachable('should have thrown')
+  } catch (e) {
+    assert.ok(e.message.includes('Middleware error'))
+  }
+})
+
+test('handles transform returning undefined', async () => {
+  const text = `
+<!-- block noReturn -->
+original content
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    transforms: {
+      noReturn: () => undefined
+    }
+  })
+
+  // Original content should be preserved when transform returns undefined
+  assert.ok(result.updatedContents.includes('original content'))
+})
+
+test('handles transform returning empty string', async () => {
+  const text = `
+<!-- block emptyReturn -->
+original content
+<!-- /block -->
+`
+  const result = await blockTransformer(text, {
+    transforms: {
+      emptyReturn: () => ''
+    }
+  })
+
+  // Empty string is falsy, so original content is preserved (per implementation)
+  assert.ok(result.updatedContents.includes('original content'))
+})
+
+test.run()

package/test/indent-string.test.js

@@ -0,0 +1,68 @@
+// Tests for indentString utility function
+
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { indentString } = require('../src')
+
+test('indentString - returns empty string unchanged', () => {
+  assert.is(indentString('', 2), '')
+})
+
+test('indentString - returns null/undefined unchanged', () => {
+  assert.is(indentString(null, 2), null)
+  assert.is(indentString(undefined, 2), undefined)
+})
+
+test('indentString - indents single line', () => {
+  assert.is(indentString('hello', 2), '  hello')
+  assert.is(indentString('hello', 4), '    hello')
+  assert.is(indentString('hello', 0), 'hello')
+})
+
+test('indentString - indents multiple lines', () => {
+  const input = 'line1\nline2\nline3'
+  const expected = '  line1\n  line2\n  line3'
+  assert.is(indentString(input, 2), expected)
+})
+
+test('indentString - preserves existing indentation', () => {
+  const input = '  already indented\n    more indented'
+  const expected = '    already indented\n      more indented'
+  assert.is(indentString(input, 2), expected)
+})
+
+test('indentString - handles empty lines in multiline string', () => {
+  const input = 'line1\n\nline3'
+  const expected = '  line1\n  \n  line3'
+  assert.is(indentString(input, 2), expected)
+})
+
+test('indentString - handles lines with only whitespace', () => {
+  const input = 'line1\n   \nline3'
+  const expected = '  line1\n     \n  line3'
+  assert.is(indentString(input, 2), expected)
+})
+
+test('indentString - handles large indent counts', () => {
+  assert.is(indentString('x', 10), '          x')
+})
+
+test('indentString - handles trailing newline', () => {
+  const input = 'line1\nline2\n'
+  const expected = '  line1\n  line2\n  '
+  assert.is(indentString(input, 2), expected)
+})
+
+test('indentString - handles leading newline', () => {
+  const input = '\nline1\nline2'
+  const expected = '  \n  line1\n  line2'
+  assert.is(indentString(input, 2), expected)
+})
+
+test('indentString - handles tabs in content', () => {
+  const input = 'line\twith\ttabs'
+  const expected = '  line\twith\ttabs'
+  assert.is(indentString(input, 2), expected)
+})
+
+test.run()