add validation and more tests

Signed-off-by: rishichawda <[email protected]>

Author: rishichawda

__tests__/custom-prefix.ts

@@ -131,4 +131,4 @@ test('remark-notes: combining custom prefix with injectStyles false', async () =
     'Should not inject styles')
 })
 
-console.log('\n✅ All custom prefix tests completed!')
+console.log('All custom prefix tests completed!')

__tests__/generate-fixtures.ts

@@ -37,7 +37,7 @@ async function generateFixtures() {
     console.log(`Generated fixture for ${type}`)
   }
 
-  console.log('\nAll fixtures generated successfully!')
+  console.log('All fixtures generated successfully!')
 }
 
 generateFixtures().catch(console.error)

__tests__/validation.ts

@@ -0,0 +1,152 @@
+/**
+ * Test validation behavior
+ */
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { unified } from 'unified'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import rehypeRaw from 'rehype-raw'
+import rehypeStringify from 'rehype-stringify'
+import remarkNotes from '../index.js'
+
+test('remark-notes: invalid note type is ignored (graceful degradation)', async () => {
+  const markdown = '> [!warning]\n> This is an invalid note type'
+  
+  const file = await unified()
+    .use(remarkParse)
+    .use(remarkNotes)
+    .use(remarkRehype, { allowDangerousHtml: true })
+    .use(rehypeRaw)
+    .use(rehypeStringify)
+    .process(markdown)
+  
+  const output = String(file)
+  
+  // Should remain as a regular blockquote
+  assert.ok(output.includes('<blockquote>'), 
+    'Invalid note type should remain as blockquote')
+  
+  // Should NOT be transformed into a note
+  assert.ok(!output.includes('class="remark-note'), 
+    'Invalid note type should not be transformed into a note')
+  
+  // Should still contain the original marker
+  assert.ok(output.includes('[!warning]'), 
+    'Original marker should be preserved for invalid types')
+})
+
+test('remark-notes: valid note types are transformed', async () => {
+  const validTypes = ['note', 'tip', 'important', 'quote', 'bonus']
+  
+  for (const type of validTypes) {
+    const markdown = `> [!${type}]\n> Test content`
+    
+    const file = await unified()
+      .use(remarkParse)
+      .use(remarkNotes)
+      .use(remarkRehype, { allowDangerousHtml: true })
+      .use(rehypeRaw)
+      .use(rehypeStringify)
+      .process(markdown)
+    
+    const output = String(file)
+    
+    // Should be transformed into a note
+    assert.ok(output.includes(`class="remark-note remark-note-${type}"`), 
+      `Valid type '${type}' should be transformed into a note`)
+    
+    // Should NOT remain as blockquote with marker
+    assert.ok(!output.includes(`[!${type}]`), 
+      `Marker should be removed for valid type '${type}'`)
+  }
+})
+
+test('remark-notes: case insensitive note type matching', async () => {
+  const variations = ['TIP', 'Tip', 'tIp', 'tiP']
+  
+  for (const variant of variations) {
+    const markdown = `> [!${variant}]\n> Test content`
+    
+    const file = await unified()
+      .use(remarkParse)
+      .use(remarkNotes)
+      .use(remarkRehype, { allowDangerousHtml: true })
+      .use(rehypeRaw)
+      .use(rehypeStringify)
+      .process(markdown)
+    
+    const output = String(file)
+    
+    // Should be transformed (case insensitive)
+    assert.ok(output.includes('class="remark-note remark-note-tip"'), 
+      `Case variant '${variant}' should be recognized as valid`)
+  }
+})
+
+test('remark-notes: multiple notes with mixed valid and invalid types', async () => {
+  const markdown = `
+> [!note]
+> Valid note
+
+> [!warning]
+> Invalid type
+
+> [!tip]
+> Another valid note
+`
+  
+  const file = await unified()
+    .use(remarkParse)
+    .use(remarkNotes)
+    .use(remarkRehype, { allowDangerousHtml: true })
+    .use(rehypeRaw)
+    .use(rehypeStringify)
+    .process(markdown)
+  
+  const output = String(file)
+  
+  // Valid notes should be transformed
+  assert.ok(output.includes('class="remark-note remark-note-note"'), 
+    'First valid note should be transformed')
+  assert.ok(output.includes('class="remark-note remark-note-tip"'), 
+    'Second valid note should be transformed')
+  
+  // Invalid note should remain as blockquote
+  assert.ok(output.includes('[!warning]'), 
+    'Invalid note marker should be preserved')
+  
+  // Count blockquotes (should have 1 for the invalid type)
+  const blockquoteMatches = output.match(/<blockquote>/g)
+  assert.ok(blockquoteMatches && blockquoteMatches.length >= 1, 
+    'At least one blockquote should remain for invalid type')
+})
+
+test('remark-notes: typos in note types are not transformed', async () => {
+  const typos = ['notte', 'tipp', 'importnt', 'qoute', 'bouns']
+  
+  for (const typo of typos) {
+    const markdown = `> [!${typo}]\n> Test content`
+    
+    const file = await unified()
+      .use(remarkParse)
+      .use(remarkNotes)
+      .use(remarkRehype, { allowDangerousHtml: true })
+      .use(rehypeRaw)
+      .use(rehypeStringify)
+      .process(markdown)
+    
+    const output = String(file)
+    
+    // Should remain as blockquote with marker
+    assert.ok(output.includes(`[!${typo}]`), 
+      `Typo '${typo}' should remain as blockquote`)
+    
+    // Should NOT be transformed
+    assert.ok(!output.includes('class="remark-note'), 
+      `Typo '${typo}' should not be transformed`)
+  }
+})
+
+console.log('All validation tests completed!')

index.ts

@@ -3,7 +3,7 @@ import type { Node, Parent } from 'unist'
 import type { Blockquote, Paragraph, Text } from 'mdast'
 import { styles } from './lib/styles.js'
 import { createNoteStructure } from './lib/node-structure.js'
-import { VALID_NOTE_TYPES, ValidNoteType } from './lib/icons-hast.js'
+import { isValidNoteType } from './lib/validation.js'
 import type { RemarkNotesOptions } from './lib/types/options.js'
 
 // Export types for public API
@@ -46,10 +46,10 @@ export default function remarkNotes(options: RemarkNotesOptions = {}) {
       const match = textNode.value.match(/^\[!(\w+)\]/)
       if (!match) return
 
-      const noteType = match[1].toLowerCase() as ValidNoteType
+      const noteType = match[1].toLowerCase()
 
-      // Only transform if it's a recognized note type
-      if (!VALID_NOTE_TYPES.includes(noteType)) return
+      // Validate note type - skip transformation if invalid (graceful degradation)
+      if (!isValidNoteType(noteType)) return
 
       // Clone children to preserve original markdown structure
       const children = [...node.children]

lib/types/options.ts

@@ -92,4 +92,4 @@ export interface RemarkNotesOptions {
      * The CSS file is available at the package export: `remark-notes-plugin/styles.css`
      */
     injectStyles?: boolean
-}
+}

lib/validation.ts

@@ -0,0 +1,71 @@
+/**
+ * Validation utilities for note types and error message generation
+ * 
+ * @module lib/validation
+ */
+
+import type { Position } from 'unist'
+import { VALID_NOTE_TYPES, ValidNoteType } from './icons-hast.js'
+
+/**
+ * Type guard to check if a string is a valid note type
+ * 
+ * @param type - The string to check
+ * @returns True if the type is a valid note type, false otherwise
+ * 
+ * @example
+ * ```typescript
+ * if (isValidNoteType(noteType)) {
+ *   // TypeScript now knows noteType is ValidNoteType
+ *   createNoteStructure(noteType, ...)
+ * }
+ * ```
+ */
+export function isValidNoteType(type: string): type is ValidNoteType {
+  return VALID_NOTE_TYPES.includes(type as ValidNoteType)
+}
+
+/**
+ * Creates a descriptive error message for invalid note types
+ * 
+ * @param invalidType - The invalid note type that was encountered
+ * @param position - Optional position information from the AST node
+ * @returns A formatted error message with context
+ * 
+ * @example
+ * ```typescript
+ * const error = createInvalidTypeError('warn', node.position)
+ * // Returns: "Invalid note type 'warn' at line 5, column 3. Valid types are: note, tip, important, quote, bonus"
+ * ```
+ */
+export function createInvalidTypeError(invalidType: string, position?: Position): string {
+  const validTypes = VALID_NOTE_TYPES.join(', ')
+  const positionInfo = position?.start 
+    ? ` at line ${position.start.line}, column ${position.start.column}` 
+    : ''
+  
+  return `Invalid note type '${invalidType}'${positionInfo}. Valid types are: ${validTypes}`
+}
+
+/**
+ * Validates a note type and throws an error if invalid
+ * 
+ * @param type - The note type to validate
+ * @param position - Optional position information for error messages
+ * @throws {Error} If the note type is invalid
+ * 
+ * @example
+ * ```typescript
+ * try {
+ *   validateNoteType(noteType, node.position)
+ *   // If we get here, noteType is valid
+ * } catch (error) {
+ *   console.error(error.message)
+ * }
+ * ```
+ */
+export function validateNoteType(type: string, position?: Position): asserts type is ValidNoteType {
+  if (!isValidNoteType(type)) {
+    throw new Error(createInvalidTypeError(type, position))
+  }
+}

package.json

@@ -36,7 +36,8 @@
     "test": "node --loader ts-node/esm __tests__/index.ts",
     "test:styles": "node --loader ts-node/esm __tests__/styles.ts",
     "test:custom-prefix": "node --loader ts-node/esm __tests__/custom-prefix.ts",
-    "test:all": "yarn test && yarn test:styles && yarn test:custom-prefix",
+    "test:validation": "node --loader ts-node/esm __tests__/validation.ts",
+    "test:all": "yarn test && yarn test:styles && yarn test:custom-prefix && yarn test:validation",
     "generate:fixtures": "node --loader ts-node/esm __tests__/generate-fixtures.ts"
   },
   "keywords": [