@link-assistant/web-capture 1.1.2 → 1.4.2

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: 'article.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('article.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('article.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('article.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/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);
+    });
+  });
+});

package/tests/unit/gdocs.test.js

@@ -0,0 +1,203 @@
+import { jest } from '@jest/globals';
+import {
+  isGoogleDocsUrl,
+  extractDocumentId,
+  buildExportUrl,
+  extractBase64Images,
+  GDOCS_EXPORT_FORMATS,
+} from '../../src/gdocs.js';
+
+jest.setTimeout(30000);
+
+describe('gdocs', () => {
+  describe('isGoogleDocsUrl', () => {
+    it('returns true for standard Google Docs edit URL', () => {
+      expect(
+        isGoogleDocsUrl(
+          'https://docs.google.com/document/d/1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4/edit'
+        )
+      ).toBe(true);
+    });
+
+    it('returns true for URL with query parameters', () => {
+      expect(
+        isGoogleDocsUrl(
+          'https://docs.google.com/document/d/abc123/edit?tab=t.0'
+        )
+      ).toBe(true);
+    });
+
+    it('returns true for URL without /edit', () => {
+      expect(
+        isGoogleDocsUrl('https://docs.google.com/document/d/abc-123_XYZ/')
+      ).toBe(true);
+    });
+
+    it('returns false for non-Google Docs URL', () => {
+      expect(isGoogleDocsUrl('https://example.com')).toBe(false);
+    });
+
+    it('returns false for Google Sheets URL', () => {
+      expect(
+        isGoogleDocsUrl('https://docs.google.com/spreadsheets/d/abc123/edit')
+      ).toBe(false);
+    });
+
+    it('returns false for empty string', () => {
+      expect(isGoogleDocsUrl('')).toBe(false);
+    });
+
+    it('returns false for null', () => {
+      expect(isGoogleDocsUrl(null)).toBe(false);
+    });
+
+    it('returns false for undefined', () => {
+      expect(isGoogleDocsUrl(undefined)).toBe(false);
+    });
+
+    it('returns false for non-string input', () => {
+      expect(isGoogleDocsUrl(123)).toBe(false);
+    });
+  });
+
+  describe('extractDocumentId', () => {
+    it('extracts document ID from standard URL', () => {
+      expect(
+        extractDocumentId(
+          'https://docs.google.com/document/d/1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4/edit'
+        )
+      ).toBe('1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4');
+    });
+
+    it('extracts document ID from URL with query params', () => {
+      expect(
+        extractDocumentId(
+          'https://docs.google.com/document/d/abc123/edit?tab=t.0'
+        )
+      ).toBe('abc123');
+    });
+
+    it('extracts document ID with hyphens and underscores', () => {
+      expect(
+        extractDocumentId('https://docs.google.com/document/d/abc-123_XYZ/')
+      ).toBe('abc-123_XYZ');
+    });
+
+    it('returns null for non-Google Docs URL', () => {
+      expect(extractDocumentId('https://example.com')).toBeNull();
+    });
+
+    it('returns null for empty string', () => {
+      expect(extractDocumentId('')).toBeNull();
+    });
+
+    it('returns null for null input', () => {
+      expect(extractDocumentId(null)).toBeNull();
+    });
+  });
+
+  describe('buildExportUrl', () => {
+    it('builds HTML export URL', () => {
+      expect(buildExportUrl('abc123', 'html')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=html'
+      );
+    });
+
+    it('builds Markdown export URL', () => {
+      expect(buildExportUrl('abc123', 'md')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=md'
+      );
+    });
+
+    it('builds PDF export URL', () => {
+      expect(buildExportUrl('abc123', 'pdf')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=pdf'
+      );
+    });
+
+    it('builds TXT export URL', () => {
+      expect(buildExportUrl('abc123', 'txt')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=txt'
+      );
+    });
+
+    it('defaults to html for unknown format', () => {
+      expect(buildExportUrl('abc123', 'invalid')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=html'
+      );
+    });
+
+    it('defaults to html when format is omitted', () => {
+      expect(buildExportUrl('abc123')).toBe(
+        'https://docs.google.com/document/d/abc123/export?format=html'
+      );
+    });
+
+    it('uses the real document ID from test document', () => {
+      const docId = '1yn5AWdus0Rh5xRr6voNy-g2wNzdC4bM0CV7SQWch9H4';
+      expect(buildExportUrl(docId, 'html')).toBe(
+        `https://docs.google.com/document/d/${docId}/export?format=html`
+      );
+    });
+  });
+
+  describe('GDOCS_EXPORT_FORMATS', () => {
+    it('contains all expected formats', () => {
+      expect(GDOCS_EXPORT_FORMATS).toEqual({
+        html: 'html',
+        txt: 'txt',
+        md: 'md',
+        pdf: 'pdf',
+        docx: 'docx',
+        epub: 'epub',
+        zip: 'zip',
+      });
+    });
+  });
+
+  describe('extractBase64Images', () => {
+    it('extracts a single PNG data URI image', () => {
+      const html = '<img src="data:image/png;base64,iVBORw0KGgo=" alt="test">';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(1);
+      expect(images[0].filename).toBe('image-01.png');
+      expect(images[0].mimeType).toBe('image/png');
+      expect(images[0].data).toBeInstanceOf(Buffer);
+      expect(updated).toContain('src="images/image-01.png"');
+      expect(updated).not.toContain('data:image');
+    });
+
+    it('extracts multiple images with correct numbering and extensions', () => {
+      const html =
+        '<img src="data:image/png;base64,AAAA" alt="a"><img src="data:image/jpeg;base64,BBBB" alt="b">';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(2);
+      expect(images[0].filename).toBe('image-01.png');
+      expect(images[1].filename).toBe('image-02.jpg');
+      expect(images[1].mimeType).toBe('image/jpeg');
+      expect(updated).toContain('images/image-01.png');
+      expect(updated).toContain('images/image-02.jpg');
+    });
+
+    it('returns empty array when no data URI images', () => {
+      const html = '<p>No images here</p>';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(0);
+      expect(updated).toBe(html);
+    });
+
+    it('preserves non-data-URI images', () => {
+      const html =
+        '<img src="https://example.com/photo.png" alt="remote"><img src="data:image/gif;base64,R0lG" alt="local">';
+      const { html: updated, images } = extractBase64Images(html);
+
+      expect(images).toHaveLength(1);
+      expect(images[0].filename).toBe('image-01.gif');
+      expect(updated).toContain('https://example.com/photo.png');
+      expect(updated).toContain('images/image-01.gif');
+    });
+  });
+});

package/tests/unit/latex.test.js

@@ -0,0 +1,123 @@
+import * as cheerio from 'cheerio';
+import {
+  extractHabrFormula,
+  extractKatexFormula,
+  extractMathJaxFormula,
+  isFormulaImage,
+  isMathElement,
+  extractFormula,
+} from '../../src/latex.js';
+
+describe('latex module', () => {
+  describe('extractHabrFormula', () => {
+    it('extracts LaTeX from Habr formula img source attribute', () => {
+      const $ = cheerio.load(
+        '<img class="formula" source=" L \\to L^2 " alt="formula">'
+      );
+      const el = $('img')[0];
+      expect(extractHabrFormula($, el)).toBe('L \\to L^2');
+    });
+
+    it('falls back to alt text when source is missing', () => {
+      const $ = cheerio.load('<img class="formula" alt=" x + y ">');
+      const el = $('img')[0];
+      expect(extractHabrFormula($, el)).toBe('x + y');
+    });
+
+    it('returns null when no source or alt', () => {
+      const $ = cheerio.load('<img class="formula">');
+      const el = $('img')[0];
+      expect(extractHabrFormula($, el)).toBeNull();
+    });
+  });
+
+  describe('extractKatexFormula', () => {
+    it('extracts from annotation element', () => {
+      const $ = cheerio.load(
+        '<span class="katex"><annotation encoding="application/x-tex">E = mc^2</annotation></span>'
+      );
+      const el = $('span.katex')[0];
+      expect(extractKatexFormula($, el)).toBe('E = mc^2');
+    });
+
+    it('extracts from data-tex attribute', () => {
+      const $ = cheerio.load(
+        '<span class="math" data-tex="\\alpha + \\beta"></span>'
+      );
+      const el = $('span.math')[0];
+      expect(extractKatexFormula($, el)).toBe('\\alpha + \\beta');
+    });
+
+    it('returns null when no TeX source found', () => {
+      const $ = cheerio.load('<span class="katex">rendered</span>');
+      const el = $('span.katex')[0];
+      expect(extractKatexFormula($, el)).toBeNull();
+    });
+  });
+
+  describe('extractMathJaxFormula', () => {
+    it('extracts from data-tex attribute', () => {
+      const $ = cheerio.load(
+        '<mjx-container data-tex="\\sum_{i=1}^{n}"></mjx-container>'
+      );
+      const el = $('mjx-container')[0];
+      expect(extractMathJaxFormula($, el)).toBe('\\sum_{i=1}^{n}');
+    });
+  });
+
+  describe('isFormulaImage', () => {
+    it('identifies img.formula elements', () => {
+      const $ = cheerio.load('<img class="formula" source="x^2">');
+      expect(isFormulaImage($, $('img')[0])).toBe(true);
+    });
+
+    it('identifies img with source attribute', () => {
+      const $ = cheerio.load('<img source="x^2">');
+      expect(isFormulaImage($, $('img')[0])).toBe(true);
+    });
+
+    it('rejects regular images', () => {
+      const $ = cheerio.load('<img src="photo.jpg" alt="photo">');
+      expect(isFormulaImage($, $('img')[0])).toBe(false);
+    });
+  });
+
+  describe('isMathElement', () => {
+    it('identifies katex elements', () => {
+      const $ = cheerio.load('<span class="katex">x</span>');
+      expect(isMathElement($, $('span')[0])).toBe(true);
+    });
+
+    it('identifies math elements', () => {
+      const $ = cheerio.load('<span class="math">x</span>');
+      expect(isMathElement($, $('span')[0])).toBe(true);
+    });
+
+    it('identifies mjx-container', () => {
+      const $ = cheerio.load('<mjx-container>x</mjx-container>');
+      expect(isMathElement($, $('mjx-container')[0])).toBe(true);
+    });
+
+    it('rejects regular elements', () => {
+      const $ = cheerio.load('<span class="text">x</span>');
+      expect(isMathElement($, $('span')[0])).toBe(false);
+    });
+  });
+
+  describe('extractFormula', () => {
+    it('extracts from Habr formula image', () => {
+      const $ = cheerio.load('<img class="formula" source="L \\to L^2">');
+      expect(extractFormula($, $('img')[0])).toBe('L \\to L^2');
+    });
+
+    it('extracts from KaTeX element', () => {
+      const $ = cheerio.load('<span class="katex" data-tex="\\alpha"></span>');
+      expect(extractFormula($, $('span')[0])).toBe('\\alpha');
+    });
+
+    it('returns null for regular elements', () => {
+      const $ = cheerio.load('<p>text</p>');
+      expect(extractFormula($, $('p')[0])).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,78 @@
+import {
+  extractImageReferences,
+  getExtensionFromUrl,
+  generateLocalFilename,
+} from '../../src/localize-images.js';
+
+describe('localize-images module', () => {
+  describe('extractImageReferences', () => {
+    it('extracts markdown image references', () => {
+      const md =
+        '![alt text](https://example.com/img.png)\n![photo](https://cdn.example.com/photo.jpg)';
+      const images = extractImageReferences(md);
+      expect(images).toHaveLength(2);
+      expect(images[0].altText).toBe('alt text');
+      expect(images[0].url).toBe('https://example.com/img.png');
+      expect(images[1].altText).toBe('photo');
+      expect(images[1].url).toBe('https://cdn.example.com/photo.jpg');
+    });
+
+    it('ignores local image references', () => {
+      const md = '![local](images/figure-1.png)';
+      const images = extractImageReferences(md);
+      expect(images).toHaveLength(0);
+    });
+
+    it('ignores non-image links', () => {
+      const md = '[link text](https://example.com)';
+      const images = extractImageReferences(md);
+      expect(images).toHaveLength(0);
+    });
+
+    it('returns empty array for no images', () => {
+      const images = extractImageReferences('plain text');
+      expect(images).toHaveLength(0);
+    });
+  });
+
+  describe('getExtensionFromUrl', () => {
+    it('detects .png extension', () => {
+      expect(getExtensionFromUrl('https://example.com/image.png')).toBe('.png');
+    });
+
+    it('detects .jpg extension', () => {
+      expect(getExtensionFromUrl('https://example.com/photo.jpg')).toBe('.jpg');
+    });
+
+    it('detects .gif extension', () => {
+      expect(getExtensionFromUrl('https://example.com/anim.gif')).toBe('.gif');
+    });
+
+    it('handles query parameters', () => {
+      expect(
+        getExtensionFromUrl('https://example.com/image.png?w=800&h=600')
+      ).toBe('.png');
+    });
+
+    it('defaults to .png for unknown extension', () => {
+      expect(getExtensionFromUrl('https://example.com/image')).toBe('.png');
+    });
+  });
+
+  describe('generateLocalFilename', () => {
+    it('generates zero-padded filename', () => {
+      expect(generateLocalFilename('https://example.com/img.png', 0)).toBe(
+        'image-01.png'
+      );
+      expect(generateLocalFilename('https://example.com/img.jpg', 9)).toBe(
+        'image-10.jpg'
+      );
+    });
+
+    it('preserves file extension from URL', () => {
+      expect(generateLocalFilename('https://example.com/photo.gif', 2)).toBe(
+        'image-03.gif'
+      );
+    });
+  });
+});