@link-assistant/web-capture 1.1.2 → 1.7.1

package/tests/unit/batch.test.js

@@ -0,0 +1,114 @@
+import {
+  getArticle,
+  getAllVersions,
+  getAllArticles,
+  createConfigFromUrls,
+  validateConfig,
+} from '../../src/batch.js';
+
+describe('batch module', () => {
+  const sampleConfig = {
+    articles: {
+      '0.0.0': {
+        url: 'https://example.com/article-1',
+        title: 'First Article',
+        language: 'en',
+      },
+      '0.0.1': {
+        url: 'https://example.com/article-2',
+        title: 'Second Article',
+        language: 'ru',
+      },
+    },
+    defaults: {
+      archivePath: 'archive',
+      markdownFile: 'document.md',
+      imagesDir: 'images',
+      hasLocalImages: true,
+    },
+  };
+
+  describe('getArticle', () => {
+    it('returns article config by version', () => {
+      const article = getArticle(sampleConfig, '0.0.0');
+      expect(article.url).toBe('https://example.com/article-1');
+      expect(article.title).toBe('First Article');
+    });
+
+    it('merges defaults into article config', () => {
+      const article = getArticle(sampleConfig, '0.0.0');
+      expect(article.markdownFile).toBe('document.md');
+      expect(article.hasLocalImages).toBe(true);
+    });
+
+    it('throws for unknown version', () => {
+      expect(() => getArticle(sampleConfig, '9.9.9')).toThrow(
+        /Unknown article version/
+      );
+    });
+  });
+
+  describe('getAllVersions', () => {
+    it('returns all version keys', () => {
+      const versions = getAllVersions(sampleConfig);
+      expect(versions).toEqual(['0.0.0', '0.0.1']);
+    });
+  });
+
+  describe('getAllArticles', () => {
+    it('returns all articles with defaults merged', () => {
+      const articles = getAllArticles(sampleConfig);
+      expect(articles).toHaveLength(2);
+      expect(articles[0].markdownFile).toBe('document.md');
+      expect(articles[1].language).toBe('ru');
+    });
+  });
+
+  describe('createConfigFromUrls', () => {
+    it('creates config from URL list', () => {
+      const config = createConfigFromUrls([
+        'https://example.com/a',
+        'https://example.com/b',
+      ]);
+      expect(Object.keys(config.articles)).toHaveLength(2);
+      expect(config.articles['1'].url).toBe('https://example.com/a');
+      expect(config.articles['2'].url).toBe('https://example.com/b');
+    });
+
+    it('sets default archive paths', () => {
+      const config = createConfigFromUrls(['https://habr.com/article/123']);
+      expect(config.articles['1'].archivePath).toContain('habr-com');
+      expect(config.articles['1'].markdownFile).toBe('document.md');
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('validates correct config', () => {
+      const result = validateConfig(sampleConfig);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('rejects config without articles', () => {
+      const result = validateConfig({});
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('articles');
+    });
+
+    it('rejects article without url', () => {
+      const result = validateConfig({
+        articles: { 1: { title: 'No URL' } },
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('missing required "url"');
+    });
+
+    it('rejects article with invalid url', () => {
+      const result = validateConfig({
+        articles: { 1: { url: 'not-a-url' } },
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0]).toContain('invalid URL');
+    });
+  });
+});

package/tests/unit/browser.test.js

@@ -80,7 +80,7 @@ describe('Browser Abstraction Layer', () => {
       expect(page.goto).toBeDefined();
       expect(page.content).toBeDefined();
       expect(page.screenshot).toBeDefined();
-      expect(page._type).toBe('puppeteer');
+      expect(page.type).toBe('puppeteer');
       await browser.close();
     });
   });
@@ -101,7 +101,7 @@ describe('Browser Abstraction Layer', () => {
       expect(page.goto).toBeDefined();
       expect(page.content).toBeDefined();
       expect(page.screenshot).toBeDefined();
-      expect(page._type).toBe('playwright');
+      expect(page.type).toBe('playwright');
       await browser.close();
     });
   });
@@ -132,5 +132,41 @@ describe('Browser Abstraction Layer', () => {
       await puppeteerBrowser.close();
       await playwrightBrowser.close();
     });
+
+    it('both adapters expose browser-commander v0.7.0+ APIs', async () => {
+      const puppeteerBrowser = await createBrowser('puppeteer');
+      const playwrightBrowser = await createBrowser('playwright');
+
+      const puppeteerPage = await puppeteerBrowser.newPage();
+      const playwrightPage = await playwrightBrowser.newPage();
+
+      // browser-commander v0.7.0: keyboard interaction
+      expect(puppeteerPage.keyboard).toBeDefined();
+      expect(puppeteerPage.keyboard.press).toBeDefined();
+      expect(puppeteerPage.keyboard.type).toBeDefined();
+      expect(playwrightPage.keyboard).toBeDefined();
+      expect(playwrightPage.keyboard.press).toBeDefined();
+
+      // browser-commander v0.7.0: dialog handling
+      expect(puppeteerPage.onDialog).toBeDefined();
+      expect(puppeteerPage.offDialog).toBeDefined();
+      expect(puppeteerPage.clearDialogHandlers).toBeDefined();
+      expect(playwrightPage.onDialog).toBeDefined();
+
+      // browser-commander v0.7.0: media emulation
+      expect(puppeteerPage.emulateMedia).toBeDefined();
+      expect(playwrightPage.emulateMedia).toBeDefined();
+
+      // browser-commander v0.8.0: PDF generation
+      expect(puppeteerPage.pdf).toBeDefined();
+      expect(playwrightPage.pdf).toBeDefined();
+
+      // browser-commander: evaluate
+      expect(puppeteerPage.evaluate).toBeDefined();
+      expect(playwrightPage.evaluate).toBeDefined();
+
+      await puppeteerBrowser.close();
+      await playwrightBrowser.close();
+    });
   });
 });

package/tests/unit/extract-images.test.js

@@ -0,0 +1,233 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import {
+  extractAndSaveImages,
+  extractBase64ToBuffers,
+  stripBase64Images,
+  hasBase64Images,
+} from '../../src/extract-images.js';
+
+describe('extract-images module', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'extract-images-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // 1x1 red PNG pixel as base64
+  const TINY_PNG =
+    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==';
+  // 1x1 white JPEG as base64
+  const TINY_JPEG =
+    '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAP///wAAAf/bAEMA/9sAQwD/2wBDAf///wAAAf/bAEMA/9sAQwD/2Q==';
+
+  function contentHash(base64Data) {
+    const buf = Buffer.from(base64Data, 'base64');
+    return createHash('sha256').update(buf).digest('hex').slice(0, 8);
+  }
+
+  const PNG_HASH = contentHash(TINY_PNG);
+  const JPEG_HASH = contentHash(TINY_JPEG);
+
+  describe('extractAndSaveImages', () => {
+    it('extracts a single PNG image from markdown', () => {
+      const md = `# Hello\n\n![test](data:image/png;base64,${TINY_PNG})\n\nEnd.`;
+      const result = extractAndSaveImages(md, tmpDir);
+
+      expect(result.extracted).toBe(1);
+      expect(result.markdown).toContain(
+        `![test](images/image-${PNG_HASH}.png)`
+      );
+      expect(result.markdown).not.toContain('data:image');
+
+      const imgPath = path.join(tmpDir, 'images', `image-${PNG_HASH}.png`);
+      expect(fs.existsSync(imgPath)).toBe(true);
+      const buf = fs.readFileSync(imgPath);
+      expect(buf.length).toBeGreaterThan(0);
+      // Verify PNG magic bytes
+      expect(buf[0]).toBe(0x89);
+      expect(buf[1]).toBe(0x50); // P
+    });
+
+    it('extracts multiple images with content-hash filenames', () => {
+      const md = [
+        `![a](data:image/png;base64,${TINY_PNG})`,
+        `![b](data:image/jpeg;base64,${TINY_JPEG})`,
+      ].join('\n');
+
+      const result = extractAndSaveImages(md, tmpDir);
+      expect(result.extracted).toBe(2);
+      expect(result.markdown).toContain(`images/image-${PNG_HASH}.png`);
+      expect(result.markdown).toContain(`images/image-${JPEG_HASH}.jpg`);
+    });
+
+    it('produces stable filenames for duplicate images', () => {
+      const md = [
+        `![a](data:image/png;base64,${TINY_PNG})`,
+        `![b](data:image/png;base64,${TINY_PNG})`,
+      ].join('\n');
+
+      const result = extractAndSaveImages(md, tmpDir);
+      expect(result.extracted).toBe(2);
+      // Both should produce the same hash-based filename
+      const matches = result.markdown.match(
+        new RegExp(`image-${PNG_HASH}\\.png`, 'g')
+      );
+      expect(matches).toHaveLength(2);
+    });
+
+    it('handles JPEG mime type correctly', () => {
+      const md = `![photo](data:image/jpeg;base64,${TINY_JPEG})`;
+      const result = extractAndSaveImages(md, tmpDir);
+
+      expect(result.extracted).toBe(1);
+      expect(result.markdown).toContain(`images/image-${JPEG_HASH}.jpg`);
+    });
+
+    it('uses custom imagesDir', () => {
+      const md = `![img](data:image/png;base64,${TINY_PNG})`;
+      const result = extractAndSaveImages(md, tmpDir, {
+        imagesDir: 'my-images',
+      });
+
+      expect(result.extracted).toBe(1);
+      expect(result.markdown).toContain(`my-images/image-${PNG_HASH}.png`);
+      expect(
+        fs.existsSync(path.join(tmpDir, 'my-images', `image-${PNG_HASH}.png`))
+      ).toBe(true);
+    });
+
+    it('returns markdown unchanged when no base64 images', () => {
+      const md = '# No images\n\nJust text.';
+      const result = extractAndSaveImages(md, tmpDir);
+
+      expect(result.extracted).toBe(0);
+      expect(result.markdown).toBe(md);
+      expect(fs.existsSync(path.join(tmpDir, 'images'))).toBe(false);
+    });
+
+    it('preserves non-base64 image references', () => {
+      const md =
+        '![remote](https://example.com/img.png)\n![local](images/existing.png)';
+      const result = extractAndSaveImages(md, tmpDir);
+
+      expect(result.extracted).toBe(0);
+      expect(result.markdown).toBe(md);
+    });
+
+    it('preserves alt text during extraction', () => {
+      const md = `![A descriptive alt text](data:image/png;base64,${TINY_PNG})`;
+      const result = extractAndSaveImages(md, tmpDir);
+
+      expect(result.markdown).toContain(
+        `![A descriptive alt text](images/image-${PNG_HASH}.png)`
+      );
+    });
+
+    it('handles SVG data URIs', () => {
+      const svgContent =
+        '<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1"><rect fill="red" width="1" height="1"/></svg>';
+      const svgBase64 = Buffer.from(svgContent).toString('base64');
+      const svgHash = contentHash(svgBase64);
+      const md = `![icon](data:image/svg+xml;base64,${svgBase64})`;
+      const result = extractAndSaveImages(md, tmpDir);
+
+      expect(result.extracted).toBe(1);
+      expect(result.markdown).toContain(`images/image-${svgHash}.svg`);
+
+      const imgPath = path.join(tmpDir, 'images', `image-${svgHash}.svg`);
+      expect(fs.existsSync(imgPath)).toBe(true);
+      const content = fs.readFileSync(imgPath, 'utf-8');
+      expect(content).toContain('<svg');
+    });
+  });
+
+  describe('extractBase64ToBuffers', () => {
+    it('extracts base64 images to in-memory buffers', () => {
+      const md = `# Hello\n\n![test](data:image/png;base64,${TINY_PNG})\n\nEnd.`;
+      const result = extractBase64ToBuffers(md);
+
+      expect(result.images).toHaveLength(1);
+      expect(result.images[0].filename).toMatch(/^image-[0-9a-f]{8}\.png$/);
+      expect(result.images[0].buffer.length).toBeGreaterThan(0);
+      expect(result.markdown).toContain(`images/${result.images[0].filename}`);
+      expect(result.markdown).not.toContain('data:image');
+    });
+
+    it('uses custom imagesDir prefix', () => {
+      const md = `![img](data:image/png;base64,${TINY_PNG})`;
+      const result = extractBase64ToBuffers(md, 'assets');
+
+      expect(result.markdown).toContain('assets/image-');
+    });
+
+    it('does not write files to disk', () => {
+      const md = `![img](data:image/png;base64,${TINY_PNG})`;
+      extractBase64ToBuffers(md);
+      expect(fs.existsSync(path.join(tmpDir, 'images'))).toBe(false);
+    });
+  });
+
+  describe('stripBase64Images', () => {
+    it('strips base64 images and leaves alt text placeholder', () => {
+      const md = `![my image](data:image/png;base64,${TINY_PNG})`;
+      const result = stripBase64Images(md);
+
+      expect(result.stripped).toBe(1);
+      expect(result.markdown).toBe('*[image: my image]*');
+      expect(result.markdown).not.toContain('data:image');
+    });
+
+    it('strips base64 images with empty alt text', () => {
+      const md = `![](data:image/png;base64,${TINY_PNG})`;
+      const result = stripBase64Images(md);
+
+      expect(result.stripped).toBe(1);
+      expect(result.markdown).toBe('');
+    });
+
+    it('preserves remote image URLs', () => {
+      const md = '![remote](https://example.com/img.png)';
+      const result = stripBase64Images(md);
+
+      expect(result.stripped).toBe(0);
+      expect(result.markdown).toBe(md);
+    });
+
+    it('strips multiple base64 images', () => {
+      const md = [
+        `![a](data:image/png;base64,${TINY_PNG})`,
+        `![b](data:image/jpeg;base64,${TINY_JPEG})`,
+        '![c](https://example.com/img.png)',
+      ].join('\n');
+      const result = stripBase64Images(md);
+
+      expect(result.stripped).toBe(2);
+      expect(result.markdown).toContain('*[image: a]*');
+      expect(result.markdown).toContain('*[image: b]*');
+      expect(result.markdown).toContain('https://example.com/img.png');
+    });
+  });
+
+  describe('hasBase64Images', () => {
+    it('returns true when markdown has base64 images', () => {
+      expect(hasBase64Images(`![x](data:image/png;base64,${TINY_PNG})`)).toBe(
+        true
+      );
+    });
+
+    it('returns false when no base64 images', () => {
+      expect(hasBase64Images('![x](https://example.com/img.png)')).toBe(false);
+    });
+
+    it('returns false for empty string', () => {
+      expect(hasBase64Images('')).toBe(false);
+    });
+  });
+});

package/tests/unit/figures.test.js

@@ -0,0 +1,74 @@
+import { extractFigures } from '../../src/figures.js';
+
+describe('figures module', () => {
+  describe('extractFigures', () => {
+    it('extracts figures with captions', () => {
+      const html = `
+        <figure>
+          <img src="https://example.com/fig1.png" alt="Graph">
+          <figcaption>Figure 1. The relationship graph</figcaption>
+        </figure>
+      `;
+      const figures = extractFigures(html, 'https://example.com');
+      expect(figures).toHaveLength(1);
+      expect(figures[0].figureNum).toBe(1);
+      expect(figures[0].src).toBe('https://example.com/fig1.png');
+      expect(figures[0].caption).toContain('Figure 1');
+    });
+
+    it('handles Russian figure captions', () => {
+      const html = `
+        <figure>
+          <img src="https://example.com/fig.png" alt="">
+          <figcaption>Рис. 5. Описание</figcaption>
+        </figure>
+      `;
+      const figures = extractFigures(html, 'https://example.com');
+      expect(figures[0].figureNum).toBe(5);
+    });
+
+    it('uses sequential numbering when no caption number', () => {
+      const html = `
+        <figure>
+          <img src="https://example.com/a.png" alt="">
+          <figcaption>Some caption without number</figcaption>
+        </figure>
+        <figure>
+          <img src="https://example.com/b.png" alt="">
+        </figure>
+      `;
+      const figures = extractFigures(html, 'https://example.com');
+      expect(figures).toHaveLength(2);
+      expect(figures[0].figureNum).toBe(1);
+      expect(figures[1].figureNum).toBe(2);
+    });
+
+    it('skips SVG images', () => {
+      const html = `
+        <figure>
+          <img src="https://example.com/icon.svg" alt="">
+        </figure>
+      `;
+      const figures = extractFigures(html, 'https://example.com');
+      expect(figures).toHaveLength(0);
+    });
+
+    it('resolves relative URLs', () => {
+      const html = `
+        <figure>
+          <img src="/images/fig.png" alt="">
+        </figure>
+      `;
+      const figures = extractFigures(html, 'https://example.com');
+      expect(figures[0].src).toBe('https://example.com/images/fig.png');
+    });
+
+    it('returns empty array for no figures', () => {
+      const figures = extractFigures(
+        '<div>no figures</div>',
+        'https://example.com'
+      );
+      expect(figures).toHaveLength(0);
+    });
+  });
+});