@bernierllc/markdown-parser 1.2.5 → 1.5.0

package/__tests__/ast-utils.test.ts

@@ -1,319 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { countNodes, visitNodes, transformNodes, findNodes, cloneNode } from '../src/utils/ast-utils';
-import { ASTNode } from '../src/types';
-
-describe('AST Utilities', () => {
-  const sampleAST: ASTNode = {
-    type: 'root',
-    children: [
-      {
-        type: 'heading',
-        attributes: { level: 1 },
-        children: [{ type: 'text', value: 'Test' }],
-      },
-      {
-        type: 'paragraph',
-        children: [
-          { type: 'text', value: 'This is ' },
-          { type: 'strong', children: [{ type: 'text', value: 'bold' }] },
-          { type: 'text', value: ' text' },
-        ],
-      },
-    ],
-  };
-
-  describe('countNodes()', () => {
-    it('should count single node', () => {
-      const node: ASTNode = { type: 'text', value: 'test' };
-      expect(countNodes(node)).toBe(1);
-    });
-
-    it('should count nested nodes', () => {
-      expect(countNodes(sampleAST)).toBe(8); // root + heading + 1 text + paragraph + 3 children + strong + 1 text
-    });
-
-    it('should handle node without children', () => {
-      const node: ASTNode = { type: 'horizontalRule' };
-      expect(countNodes(node)).toBe(1);
-    });
-
-    it('should handle empty children array', () => {
-      const node: ASTNode = { type: 'root', children: [] };
-      expect(countNodes(node)).toBe(1);
-    });
-
-    it('should count deeply nested structure', () => {
-      const deepNode: ASTNode = {
-        type: 'root',
-        children: [
-          {
-            type: 'blockquote',
-            children: [
-              {
-                type: 'blockquote',
-                children: [
-                  {
-                    type: 'paragraph',
-                    children: [{ type: 'text', value: 'nested' }],
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      };
-      expect(countNodes(deepNode)).toBe(5);
-    });
-  });
-
-  describe('visitNodes()', () => {
-    it('should visit all nodes', () => {
-      const visited: string[] = [];
-      visitNodes(sampleAST, (node) => {
-        visited.push(node.type);
-      });
-
-      expect(visited).toContain('root');
-      expect(visited).toContain('heading');
-      expect(visited).toContain('paragraph');
-      expect(visited).toContain('text');
-      expect(visited).toContain('strong');
-      expect(visited.length).toBe(8);
-    });
-
-    it('should visit nodes in depth-first order', () => {
-      const node: ASTNode = {
-        type: 'root',
-        children: [
-          { type: 'heading', children: [{ type: 'text', value: 'h1' }] },
-          { type: 'paragraph', children: [{ type: 'text', value: 'p1' }] },
-        ],
-      };
-
-      const order: string[] = [];
-      visitNodes(node, (n) => {
-        order.push(n.type);
-      });
-
-      expect(order).toEqual(['root', 'heading', 'text', 'paragraph', 'text']);
-    });
-
-    it('should handle single node', () => {
-      const visited: string[] = [];
-      visitNodes({ type: 'text', value: 'test' }, (node) => {
-        visited.push(node.type);
-      });
-
-      expect(visited).toEqual(['text']);
-    });
-  });
-
-  describe('transformNodes()', () => {
-    it('should transform matching nodes', () => {
-      const transformed = transformNodes(sampleAST, (node) => {
-        if (node.type === 'text' && node.value) {
-          return { ...node, value: node.value.toUpperCase() };
-        }
-        return node;
-      });
-
-      const texts: string[] = [];
-      visitNodes(transformed, (node) => {
-        if (node.type === 'text' && node.value) {
-          texts.push(node.value);
-        }
-      });
-
-      expect(texts.every((text) => text === text.toUpperCase())).toBe(true);
-    });
-
-    it('should preserve structure', () => {
-      const transformed = transformNodes(sampleAST, (node) => node);
-
-      expect(countNodes(transformed)).toBe(countNodes(sampleAST));
-      expect(transformed.type).toBe(sampleAST.type);
-    });
-
-    it('should handle node type changes', () => {
-      const transformed = transformNodes(sampleAST, (node) => {
-        if (node.type === 'strong') {
-          return { ...node, type: 'emphasis' };
-        }
-        return node;
-      });
-
-      const hasStrong = findNodes(transformed, (n) => n.type === 'strong');
-      const hasEmphasis = findNodes(transformed, (n) => n.type === 'emphasis');
-
-      expect(hasStrong.length).toBe(0);
-      expect(hasEmphasis.length).toBe(1);
-    });
-
-    it('should handle attribute modifications', () => {
-      const transformed = transformNodes(sampleAST, (node) => {
-        if (node.type === 'heading') {
-          return {
-            ...node,
-            attributes: { ...node.attributes, id: 'test-id' },
-          };
-        }
-        return node;
-      });
-
-      const headings = findNodes(transformed, (n) => n.type === 'heading');
-      expect(headings[0].attributes!.id).toBe('test-id');
-    });
-  });
-
-  describe('findNodes()', () => {
-    it('should find nodes matching predicate', () => {
-      const textNodes = findNodes(sampleAST, (node) => node.type === 'text');
-      expect(textNodes.length).toBeGreaterThan(0);
-      expect(textNodes.every((node) => node.type === 'text')).toBe(true);
-    });
-
-    it('should find nodes with specific attributes', () => {
-      const level1Headings = findNodes(
-        sampleAST,
-        (node) => node.type === 'heading' && node.attributes?.level === 1
-      );
-      expect(level1Headings.length).toBe(1);
-    });
-
-    it('should return empty array when no matches', () => {
-      const images = findNodes(sampleAST, (node) => node.type === 'image');
-      expect(images).toEqual([]);
-    });
-
-    it('should find all matching nodes at any depth', () => {
-      const deepAST: ASTNode = {
-        type: 'root',
-        children: [
-          {
-            type: 'blockquote',
-            children: [
-              { type: 'paragraph', children: [{ type: 'text', value: '1' }] },
-              {
-                type: 'blockquote',
-                children: [{ type: 'paragraph', children: [{ type: 'text', value: '2' }] }],
-              },
-            ],
-          },
-        ],
-      };
-
-      const texts = findNodes(deepAST, (node) => node.type === 'text');
-      expect(texts.length).toBe(2);
-    });
-
-    it('should handle complex predicates', () => {
-      const nodes = findNodes(
-        sampleAST,
-        (node) => node.type === 'text' && node.value !== undefined && node.value.length > 3
-      );
-      expect(nodes.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('cloneNode()', () => {
-    it('should create deep copy', () => {
-      const cloned = cloneNode(sampleAST);
-
-      expect(cloned).not.toBe(sampleAST);
-      expect(cloned).toEqual(sampleAST);
-    });
-
-    it('should not affect original when modifying clone', () => {
-      const cloned = cloneNode(sampleAST);
-      (cloned as unknown as { type: string }).type = 'modified';
-
-      expect(sampleAST.type).toBe('root');
-      expect((cloned as unknown as { type: string }).type).toBe('modified');
-    });
-
-    it('should clone children deeply', () => {
-      const cloned = cloneNode(sampleAST);
-      (cloned.children![0] as unknown as { type: string }).type = 'modified';
-
-      expect(sampleAST.children![0].type).toBe('heading');
-      expect((cloned.children![0] as unknown as { type: string }).type).toBe('modified');
-    });
-
-    it('should clone attributes', () => {
-      const node: ASTNode = {
-        type: 'heading',
-        attributes: { level: 1, id: 'test' },
-      };
-
-      const cloned = cloneNode(node);
-      cloned.attributes!.level = 2;
-
-      expect(node.attributes!.level).toBe(1);
-      expect(cloned.attributes!.level).toBe(2);
-    });
-
-    it('should clone position information', () => {
-      const node: ASTNode = {
-        type: 'heading',
-        position: {
-          start: { line: 1, column: 0, offset: 0 },
-          end: { line: 1, column: 10, offset: 10 },
-        },
-      };
-
-      const cloned = cloneNode(node);
-      cloned.position!.start.line = 2;
-
-      expect(node.position!.start.line).toBe(1);
-      expect(cloned.position!.start.line).toBe(2);
-    });
-
-    it('should handle node without children', () => {
-      const node: ASTNode = { type: 'text', value: 'test' };
-      const cloned = cloneNode(node);
-
-      expect(cloned).toEqual(node);
-      expect(cloned).not.toBe(node);
-    });
-
-    it('should handle empty children array', () => {
-      const node: ASTNode = { type: 'root', children: [] };
-      const cloned = cloneNode(node);
-
-      expect(cloned.children).toEqual([]);
-      expect(cloned.children).not.toBe(node.children);
-    });
-  });
-
-  describe('Utility combinations', () => {
-    it('should work together for complex operations', () => {
-      // Find all text nodes (for verification purposes)
-      findNodes(sampleAST, (node) => node.type === 'text');
-
-      // Clone the AST
-      const cloned = cloneNode(sampleAST);
-
-      // Transform the clone
-      const transformed = transformNodes(cloned, (node) => {
-        if (node.type === 'text' && node.value) {
-          return { ...node, value: node.value.toUpperCase() };
-        }
-        return node;
-      });
-
-      // Count nodes
-      expect(countNodes(transformed)).toBe(countNodes(sampleAST));
-
-      // Original should be unchanged
-      const originalTexts = findNodes(sampleAST, (node) => node.type === 'text');
-      expect(originalTexts[0].value).not.toBe(originalTexts[0].value?.toUpperCase());
-    });
-  });
-});

package/__tests__/cache.test.ts

@@ -1,243 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { MarkdownParser } from '../src/MarkdownParser';
-
-describe('MarkdownParser - Caching', () => {
-  describe('Cache behavior', () => {
-    it('should cache parsed AST when enabled', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const markdown = '# Test Heading';
-
-      const result1 = await parser.parse(markdown);
-      const result2 = await parser.parse(markdown);
-
-      expect(result1.success).toBe(true);
-      expect(result2.success).toBe(true);
-      expect(result1.metadata!.cached).toBe(false);
-      expect(result2.metadata!.cached).toBe(true);
-      // Cached result should be fast (allow for timing variations)
-      expect(result2.metadata!.parseTime).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should not cache when disabled', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: false } });
-      const markdown = '# Test';
-
-      const result1 = await parser.parse(markdown);
-      const result2 = await parser.parse(markdown);
-
-      expect(result1.metadata!.cached).toBe(false);
-      expect(result2.metadata!.cached).toBe(false);
-    });
-
-    it('should respect cache TTL', async () => {
-      const parser = new MarkdownParser({
-        cache: { enabled: true, ttl: 1 }, // 1 second
-      });
-      const markdown = '# Test';
-
-      await parser.parse(markdown);
-
-      // Wait for TTL to expire
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      const result = await parser.parse(markdown);
-      expect(result.metadata!.cached).toBe(false); // Cache expired
-    });
-
-    it('should enforce cache size limit', async () => {
-      const parser = new MarkdownParser({
-        cache: { enabled: true, maxSize: 2 },
-      });
-
-      await parser.parse('# Doc 1');
-      await parser.parse('# Doc 2');
-      await parser.parse('# Doc 3'); // Should evict Doc 1
-
-      // Cache size should be at max
-      expect(parser.getCacheStats().size).toBe(2);
-
-      // First document should no longer be cached (was evicted)
-      const result = await parser.parse('# Doc 1');
-      expect(result.metadata!.cached).toBe(false);
-    });
-
-    it('should cache different content separately', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-
-      await parser.parse('# Doc 1');
-      await parser.parse('# Doc 2');
-
-      const result1 = await parser.parse('# Doc 1');
-      const result2 = await parser.parse('# Doc 2');
-
-      expect(result1.metadata!.cached).toBe(true);
-      expect(result2.metadata!.cached).toBe(true);
-      expect(result1.ast).not.toEqual(result2.ast);
-    });
-  });
-
-  describe('Cache management', () => {
-    it('should clear cache on demand', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const markdown = '# Test';
-
-      await parser.parse(markdown);
-
-      const stats1 = parser.getCacheStats();
-      expect(stats1.size).toBe(1);
-
-      parser.clearCache();
-
-      const stats2 = parser.getCacheStats();
-      expect(stats2.size).toBe(0);
-
-      const result = await parser.parse(markdown);
-      expect(result.metadata!.cached).toBe(false);
-    });
-
-    it('should get accurate cache statistics', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-
-      const stats1 = parser.getCacheStats();
-      expect(stats1.enabled).toBe(true);
-      expect(stats1.size).toBe(0);
-
-      await parser.parse('# Test 1');
-      const stats2 = parser.getCacheStats();
-      expect(stats2.size).toBe(1);
-
-      await parser.parse('# Test 2');
-      await parser.parse('# Test 3');
-      const stats3 = parser.getCacheStats();
-      expect(stats3.size).toBe(3);
-    });
-
-    it('should prune expired entries', async () => {
-      const parser = new MarkdownParser({
-        cache: { enabled: true, ttl: 1 },
-      });
-
-      await parser.parse('# Test 1');
-      await parser.parse('# Test 2');
-      await parser.parse('# Test 3');
-
-      const stats1 = parser.getCacheStats();
-      expect(stats1.size).toBe(3);
-
-      // Wait for expiration
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      const removed = parser.pruneCache();
-      expect(removed).toBe(3);
-
-      const stats2 = parser.getCacheStats();
-      expect(stats2.size).toBe(0);
-    });
-
-    it('should only prune expired entries', async () => {
-      const parser = new MarkdownParser({
-        cache: { enabled: true, ttl: 2 },
-      });
-
-      await parser.parse('# Test 1');
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      await parser.parse('# Test 2');
-
-      // Wait for first entry to expire but not second
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      const removed = parser.pruneCache();
-      expect(removed).toBe(1);
-
-      const stats = parser.getCacheStats();
-      expect(stats.size).toBe(1);
-    });
-  });
-
-  describe('Cache performance', () => {
-    it('should improve parse time with caching', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const markdown = '# Heading\n\n' + 'Paragraph '.repeat(100);
-
-      await parser.parse(markdown);
-      const result2 = await parser.parse(markdown);
-
-      expect(result2.metadata!.cached).toBe(true);
-    });
-
-    it('should handle large cache efficiently', async () => {
-      const parser = new MarkdownParser({
-        cache: { enabled: true, maxSize: 1000 },
-      });
-
-      // Add 100 entries
-      for (let i = 0; i < 100; i++) {
-        await parser.parse(`# Document ${i}`);
-      }
-
-      const stats = parser.getCacheStats();
-      expect(stats.size).toBe(100);
-
-      // Cache lookups should be fast
-      await parser.parse('# Document 50');
-
-      // Verify cached result
-      expect(stats.size).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Cache edge cases', () => {
-    it('should handle empty document caching', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-
-      await parser.parse('');
-      const result2 = await parser.parse('');
-
-      expect(result2.success).toBe(true);
-      expect(result2.metadata!.cached).toBe(true);
-    });
-
-    it('should handle whitespace-only document caching', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-
-      await parser.parse('   \n   \n   ');
-      const result2 = await parser.parse('   \n   \n   ');
-
-      expect(result2.metadata!.cached).toBe(true);
-    });
-
-    it('should cache large documents', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const largeMarkdown = '# Heading\n\n'.repeat(1000) + 'Paragraph '.repeat(5000);
-
-      await parser.parse(largeMarkdown);
-      const result2 = await parser.parse(largeMarkdown);
-
-      expect(result2.metadata!.cached).toBe(true);
-    });
-
-    it('should handle concurrent parse requests', async () => {
-      const parser = new MarkdownParser({ cache: { enabled: true } });
-      const markdown = '# Test';
-
-      // Parse the same document multiple times concurrently
-      const results = await Promise.all([
-        parser.parse(markdown),
-        parser.parse(markdown),
-        parser.parse(markdown),
-      ]);
-
-      expect(results.every((r) => r.success)).toBe(true);
-      // At least one should be cached (depending on execution order)
-      const cachedCount = results.filter((r) => r.metadata!.cached).length;
-      expect(cachedCount).toBeGreaterThanOrEqual(0);
-    });
-  });
-});