@link-assistant/web-capture 1.12.0 → 2.0.1

package/tests/unit/metadata.test.js

@@ -1,140 +0,0 @@
-import * as cheerio from 'cheerio';
-import {
-  extractMetadata,
-  formatMetadataBlock,
-  formatFooterBlock,
-} from '../../src/metadata.js';
-
-describe('metadata module', () => {
-  describe('extractMetadata', () => {
-    it('extracts author information', () => {
-      const $ = cheerio.load(
-        '<a class="tm-user-info__username" href="/user/john">john_doe</a>'
-      );
-      const meta = extractMetadata($);
-      expect(meta.author).toBe('john_doe');
-      expect(meta.authorUrl).toBe('/user/john');
-    });
-
-    it('extracts publication date', () => {
-      const $ = cheerio.load(
-        '<time datetime="2024-01-15T10:00:00Z">Jan 15</time>'
-      );
-      const meta = extractMetadata($);
-      expect(meta.publishDate).toBe('2024-01-15T10:00:00Z');
-      expect(meta.publishDateText).toBe('Jan 15');
-    });
-
-    it('extracts hubs', () => {
-      const $ = cheerio.load(`
-        <a class="tm-publication-hub__link"><span>Math</span></a>
-        <a class="tm-publication-hub__link"><span>Science</span></a>
-      `);
-      const meta = extractMetadata($);
-      expect(meta.hubs).toEqual(['Math', 'Science']);
-    });
-
-    it('extracts tags from meta keywords', () => {
-      const $ = cheerio.load(
-        '<meta name="keywords" content="math, science, theory">'
-      );
-      const meta = extractMetadata($);
-      expect(meta.tags).toEqual(['math', 'science', 'theory']);
-    });
-
-    it('extracts LD+JSON author name', () => {
-      const $ = cheerio.load(
-        '<script type="application/ld+json">{"author":{"name":"John Doe"},"dateModified":"2024-02-01"}</script>'
-      );
-      const meta = extractMetadata($);
-      expect(meta.authorFullName).toBe('John Doe');
-      expect(meta.dateModified).toBe('2024-02-01');
-    });
-
-    it('extracts votes and comments', () => {
-      const $ = cheerio.load(`
-        <span class="tm-votes-meter__value">+42</span>
-        <span class="tm-article-comments-counter-link__value">15</span>
-      `);
-      const meta = extractMetadata($);
-      expect(meta.votes).toBe('+42');
-      expect(meta.comments).toBe('15');
-    });
-
-    it('returns empty object for minimal HTML', () => {
-      const $ = cheerio.load('<div>plain content</div>');
-      const meta = extractMetadata($);
-      expect(meta).toBeDefined();
-      expect(meta.author).toBeUndefined();
-    });
-  });
-
-  describe('formatMetadataBlock', () => {
-    it('formats author line with link', () => {
-      const lines = formatMetadataBlock({
-        author: 'john',
-        authorUrl: '/user/john',
-      });
-      expect(lines).toContain('**Author:** [john](/user/john)');
-    });
-
-    it('formats author with full name', () => {
-      const lines = formatMetadataBlock({
-        author: 'john',
-        authorFullName: 'John Doe',
-        authorUrl: '/user/john',
-      });
-      expect(lines[0]).toContain('John Doe (john)');
-    });
-
-    it('formats publication date', () => {
-      const lines = formatMetadataBlock({
-        publishDate: '2024-01-15T10:00:00Z',
-      });
-      expect(lines.some((l) => l.includes('Published:'))).toBe(true);
-      expect(lines.some((l) => l.includes('January 15, 2024'))).toBe(true);
-    });
-
-    it('includes hubs and tags', () => {
-      const lines = formatMetadataBlock({
-        hubs: ['Math', 'Science'],
-        tags: ['theory', 'links'],
-      });
-      expect(lines.some((l) => l.includes('Math, Science'))).toBe(true);
-      expect(lines.some((l) => l.includes('theory, links'))).toBe(true);
-    });
-
-    it('returns empty array for null metadata', () => {
-      expect(formatMetadataBlock(null)).toEqual([]);
-    });
-  });
-
-  describe('formatFooterBlock', () => {
-    it('includes separator line', () => {
-      const lines = formatFooterBlock({ author: 'test' });
-      expect(lines[0]).toBe('---');
-    });
-
-    it('formats tag links', () => {
-      const lines = formatFooterBlock({
-        tagLinks: [{ name: 'math', url: '/tag/math' }],
-      });
-      expect(lines.some((l) => l.includes('[math](/tag/math)'))).toBe(true);
-    });
-
-    it('formats article stats', () => {
-      const lines = formatFooterBlock({
-        votes: '+10',
-        views: '5000',
-        comments: '3',
-      });
-      const statsLine = lines.find((l) => l.includes('Votes:'));
-      expect(statsLine).toContain('+10');
-      expect(statsLine).toContain('5000');
-    });
-
-    it('returns empty array for null metadata', () => {
-      expect(formatFooterBlock(null)).toEqual([]);
-    });
-  });
-});

package/tests/unit/package-runtime-dependencies.test.js

@@ -1,74 +0,0 @@
-import { readFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const jsRoot = resolve(__dirname, '../..');
-
-function readJson(relativePath) {
-  return JSON.parse(readFileSync(resolve(jsRoot, relativePath), 'utf8'));
-}
-
-function collectProductionDependencies(packageLock, packageName) {
-  const visited = new Set();
-
-  function visit(name) {
-    if (visited.has(name)) {
-      return;
-    }
-    visited.add(name);
-
-    const entry = packageLock.packages[`node_modules/${name}`];
-    for (const dependency of Object.keys(entry?.dependencies || {})) {
-      visit(dependency);
-    }
-  }
-
-  visit(packageName);
-  return visited;
-}
-
-const runtimeImports = [
-  {
-    packageName: 'turndown-plugin-gfm',
-    sourceFile: 'src/lib.js',
-  },
-];
-
-describe('runtime package dependencies', () => {
-  test('archiver production dependencies do not include deprecated glob', () => {
-    const packageLock = readJson('package-lock.json');
-    const dependencies = collectProductionDependencies(packageLock, 'archiver');
-
-    expect([...dependencies]).not.toContain('glob');
-  });
-
-  test.each(runtimeImports)(
-    '$packageName is declared as a production dependency',
-    ({ packageName, sourceFile }) => {
-      const source = readFileSync(resolve(jsRoot, sourceFile), 'utf8');
-      const packageJson = readJson('package.json');
-
-      expect(source).toContain(`from '${packageName}'`);
-      expect(packageJson.dependencies).toHaveProperty(packageName);
-      expect(packageJson.devDependencies || {}).not.toHaveProperty(packageName);
-    }
-  );
-
-  test.each(runtimeImports)(
-    '$packageName is not marked dev-only in package-lock.json',
-    ({ packageName }) => {
-      const packageLock = readJson('package-lock.json');
-
-      expect(packageLock.packages[''].dependencies).toHaveProperty(packageName);
-      expect(packageLock.packages[''].devDependencies || {}).not.toHaveProperty(
-        packageName
-      );
-      expect(packageLock.packages[`node_modules/${packageName}`]).toBeDefined();
-      expect(packageLock.packages[`node_modules/${packageName}`].dev).not.toBe(
-        true
-      );
-    }
-  );
-});

package/tests/unit/paragraph-vs-line-break.test.js

@@ -1,56 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import MarkdownIt from 'markdown-it';
-import {
-  convertHtmlToMarkdown,
-  convertHtmlToMarkdownEnhanced,
-} from '../../src/lib.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const HTML = fs.readFileSync(
-  path.join(__dirname, '..', 'fixtures', 'paragraph-vs-line-break.html'),
-  'utf8'
-);
-
-describe('<br><br> coalesces to a paragraph break (not two hard breaks)', () => {
-  it('renders a paragraph break between Caption A and Caption B (convertHtmlToMarkdown)', () => {
-    const md = convertHtmlToMarkdown(HTML);
-    const lines = md.split('\n');
-    const idxA = lines.findIndex((l) => l.includes('Caption A:'));
-    const idxB = lines.findIndex((l) => l.includes('Caption B:'));
-    expect(idxA).toBeGreaterThanOrEqual(0);
-    expect(idxB).toBeGreaterThan(idxA);
-
-    const between = lines.slice(idxA + 1, idxB);
-    expect(between.some((l) => l === '')).toBe(true);
-
-    expect(md).not.toMatch(/^[ \t]+ {2}$/m);
-  });
-
-  it('renders a paragraph break between Caption A and Caption B (convertHtmlToMarkdownEnhanced)', () => {
-    const { markdown } = convertHtmlToMarkdownEnhanced(HTML);
-    const lines = markdown.split('\n');
-    const idxA = lines.findIndex((l) => l.includes('Caption A:'));
-    const idxB = lines.findIndex((l) => l.includes('Caption B:'));
-    expect(idxA).toBeGreaterThanOrEqual(0);
-    expect(idxB).toBeGreaterThan(idxA);
-
-    const between = lines.slice(idxA + 1, idxB);
-    expect(between.some((l) => l === '')).toBe(true);
-
-    expect(markdown).not.toMatch(/^[ \t]+ {2}$/m);
-  });
-
-  it('CommonMark renders Caption A and Caption B as separate paragraphs', () => {
-    const md = convertHtmlToMarkdown(HTML);
-    const html = new MarkdownIt('commonmark').render(md);
-    const aIdx = html.indexOf('Caption A:');
-    const bIdx = html.indexOf('Caption B:');
-    expect(aIdx).toBeGreaterThan(-1);
-    expect(bIdx).toBeGreaterThan(aIdx);
-    const between = html.slice(aIdx, bIdx);
-    expect(between).toMatch(/<\/p>\s*<p>/);
-  });
-});

package/tests/unit/postprocess.test.js

@@ -1,110 +0,0 @@
-import {
-  postProcessMarkdown,
-  applyUnicodeNormalization,
-  applyLatexSpacingFixes,
-  applyPercentSignFix,
-  applyBoldFormattingFixes,
-} from '../../src/postprocess.js';
-
-describe('postprocess module', () => {
-  describe('applyUnicodeNormalization', () => {
-    it('preserves non-breaking spaces as   entities', () => {
-      expect(applyUnicodeNormalization('hello\u00A0world')).toBe(
-        'hello world'
-      );
-    });
-
-    it('normalizes curly quotes to straight quotes', () => {
-      expect(applyUnicodeNormalization('\u2018hello\u2019')).toBe("'hello'");
-      expect(applyUnicodeNormalization('\u201Chello\u201D')).toBe('"hello"');
-    });
-
-    it('normalizes en-dash to hyphen', () => {
-      expect(applyUnicodeNormalization('2\u20133')).toBe('2-3');
-    });
-
-    it('normalizes ellipsis', () => {
-      expect(applyUnicodeNormalization('wait\u2026')).toBe('wait...');
-    });
-  });
-
-  describe('applyLatexSpacingFixes', () => {
-    it('adds space before formula after word character', () => {
-      const result = applyLatexSpacingFixes('where$x$is');
-      expect(result).toBe('where $x$ is');
-    });
-
-    it('trims whitespace inside formula delimiters', () => {
-      const result = applyLatexSpacingFixes('$ x + y $');
-      expect(result).toBe('$x + y$');
-    });
-
-    it('does not modify block formulas', () => {
-      const result = applyLatexSpacingFixes('$$x + y$$');
-      expect(result).toBe('$$x + y$$');
-    });
-
-    it('does not modify blockquote block formulas', () => {
-      const result = applyLatexSpacingFixes('> $$x + y$$');
-      expect(result).toBe('> $$x + y$$');
-    });
-
-    it('handles multiple formulas on one line', () => {
-      const result = applyLatexSpacingFixes('$a$and$b$');
-      expect(result).toBe('$a$ and $b$');
-    });
-  });
-
-  describe('applyPercentSignFix', () => {
-    it('fixes percent sign in inline formulas', () => {
-      const result = applyPercentSignFix('$50\\%$');
-      expect(result).toBe('$50\\\\%$');
-    });
-
-    it('fixes \\text{%} notation', () => {
-      const result = applyPercentSignFix('$50\\text{%}$');
-      expect(result).toBe('$50\\\\%$');
-    });
-  });
-
-  describe('applyBoldFormattingFixes', () => {
-    it('removes empty bold markers', () => {
-      const result = applyBoldFormattingFixes('hello ** ** world');
-      expect(result).toBe('hello  world');
-    });
-
-    it('trims content inside bold markers', () => {
-      const result = applyBoldFormattingFixes('** hello **');
-      expect(result).toBe('**hello**');
-    });
-
-    it('adds space between word and bold', () => {
-      const result = applyBoldFormattingFixes('word**bold**next');
-      expect(result).toBe('word **bold** next');
-    });
-  });
-
-  describe('postProcessMarkdown', () => {
-    it('applies all transformations by default', () => {
-      const input = 'hello\u00A0$x$world';
-      const result = postProcessMarkdown(input);
-      expect(result).toContain('hello');
-      expect(result).toContain('$x$');
-      expect(result).not.toContain('\u00A0');
-    });
-
-    it('respects option flags', () => {
-      const input = 'hello\u00A0world';
-      const result = postProcessMarkdown(input, {
-        normalizeUnicode: false,
-      });
-      expect(result).toContain('\u00A0');
-    });
-
-    it('removes stray standalone $ signs', () => {
-      const input = 'line1\n$\nline2';
-      const result = postProcessMarkdown(input);
-      expect(result).toBe('line1\n\nline2');
-    });
-  });
-});

package/tests/unit/proxy-headers.test.js

@@ -1,100 +0,0 @@
-import {
-  copyProxyResponseHeaders,
-  getProxyHeaderEntries,
-} from '../../src/proxy-headers.js';
-
-describe('proxy header helpers', () => {
-  it('removes hop-by-hop headers and headers named by Connection', () => {
-    const entries = getProxyHeaderEntries(
-      headers({
-        'Content-Type': 'text/html',
-        Connection: 'keep-alive, X-Internal-Hop',
-        'Keep-Alive': 'timeout=5',
-        TE: 'trailers',
-        Trailer: 'Expires',
-        Upgrade: 'websocket',
-        'Proxy-Authenticate': 'Basic',
-        'Proxy-Authorization': 'Basic token',
-        'Transfer-Encoding': 'chunked',
-        'X-Internal-Hop': 'remove me',
-        'X-End-To-End': 'keep me',
-      })
-    );
-
-    expect(Object.fromEntries(entries)).toEqual({
-      'content-type': 'text/html',
-      'x-end-to-end': 'keep me',
-    });
-  });
-
-  it('preserves content length only for unencoded streaming responses', () => {
-    expect(
-      Object.fromEntries(
-        getProxyHeaderEntries(
-          headers({
-            'Content-Type': 'text/plain',
-            'Content-Length': '12',
-          }),
-          { preserveContentLength: true }
-        )
-      )
-    ).toEqual({
-      'content-type': 'text/plain',
-      'content-length': '12',
-    });
-
-    expect(
-      Object.fromEntries(
-        getProxyHeaderEntries(
-          headers({
-            'Content-Type': 'text/plain',
-            'Content-Length': '12',
-            'Content-Encoding': 'gzip',
-          }),
-          { preserveContentLength: true }
-        )
-      )
-    ).toEqual({
-      'content-type': 'text/plain',
-    });
-  });
-
-  it('sets a default content type while copying safe headers', () => {
-    const res = responseRecorder();
-
-    copyProxyResponseHeaders(
-      headers({
-        ETag: '"abc"',
-      }),
-      res
-    );
-
-    expect(res.headers).toEqual({
-      'content-type': 'text/plain',
-      etag: '"abc"',
-    });
-  });
-});
-
-function headers(values) {
-  const map = new Map(
-    Object.entries(values).map(([key, value]) => [key.toLowerCase(), value])
-  );
-  return {
-    get(key) {
-      return map.get(key.toLowerCase()) || null;
-    },
-    entries() {
-      return map.entries();
-    },
-  };
-}
-
-function responseRecorder() {
-  return {
-    headers: {},
-    setHeader(key, value) {
-      this.headers[key.toLowerCase()] = value;
-    },
-  };
-}

package/tests/unit/publish-verification.test.js

@@ -1,57 +0,0 @@
-import { jest } from '@jest/globals';
-
-const originalFetch = global.fetch;
-
-beforeAll(() => {
-  global.fetch = jest.fn().mockResolvedValue({
-    text: async () => `
-      ({
-        use: async (name) => {
-          if (name === 'command-stream') return { $: () => ({ run: async () => ({ code: 0, stdout: '', stderr: '' }) }) };
-          if (name === 'lino-arguments') return { makeConfig: () => ({ shouldPull: false, jsRoot: 'js' }) };
-          throw new Error('Unexpected dynamic import: ' + name);
-        }
-      })
-    `,
-  });
-});
-
-afterAll(() => {
-  global.fetch = originalFetch;
-});
-
-describe('publish verification', () => {
-  test('keeps polling verification through transient npm 404s', async () => {
-    const { verifyPublishedVersionWithRunner } =
-      await import('../../../scripts/publish-to-npm.mjs');
-
-    const runVerify = jest
-      .fn()
-      .mockResolvedValueOnce({
-        code: 1,
-        stdout: '',
-        stderr: 'npm error code E404',
-      })
-      .mockResolvedValueOnce({
-        code: 1,
-        stdout: '',
-        stderr: 'npm error code E404',
-      })
-      .mockResolvedValueOnce({
-        code: 0,
-        stdout: '1.7.1\n',
-        stderr: '',
-      });
-    const sleepFn = jest.fn().mockResolvedValue(undefined);
-
-    const published = await verifyPublishedVersionWithRunner(
-      '1.7.1',
-      runVerify,
-      sleepFn
-    );
-
-    expect(published).toBe(true);
-    expect(runVerify).toHaveBeenCalledTimes(3);
-    expect(sleepFn).toHaveBeenCalledTimes(2);
-  });
-});

package/tests/unit/retry.test.js

@@ -1,111 +0,0 @@
-import { jest } from '@jest/globals';
-import { retry } from '../../src/retry.js';
-
-jest.setTimeout(30000);
-
-describe('retry', () => {
-  it('returns result on first success', async () => {
-    const fn = jest.fn().mockResolvedValue('ok');
-    const result = await retry(fn, { retries: 3 });
-    expect(result).toBe('ok');
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('retries on failure and succeeds eventually', async () => {
-    let calls = 0;
-    const fn = jest.fn().mockImplementation(async () => {
-      calls++;
-      if (calls < 3) {
-        throw new Error('fail');
-      }
-      return 'success';
-    });
-
-    const result = await retry(fn, { retries: 3, baseDelay: 50 });
-    expect(result).toBe('success');
-    expect(fn).toHaveBeenCalledTimes(3);
-  });
-
-  it('throws after exhausting retries', async () => {
-    const fn = jest.fn().mockRejectedValue(new Error('persistent failure'));
-
-    await expect(retry(fn, { retries: 2, baseDelay: 50 })).rejects.toThrow(
-      'persistent failure'
-    );
-    expect(fn).toHaveBeenCalledTimes(3); // initial + 2 retries
-  });
-
-  it('calls onRetry callback before each retry', async () => {
-    let calls = 0;
-    const fn = jest.fn().mockImplementation(async () => {
-      calls++;
-      if (calls < 2) {
-        throw new Error('fail');
-      }
-      return 'ok';
-    });
-    const onRetry = jest.fn();
-
-    await retry(fn, { retries: 3, baseDelay: 50, onRetry });
-    expect(onRetry).toHaveBeenCalledTimes(1);
-    expect(onRetry).toHaveBeenCalledWith(expect.any(Error), 1, 50);
-  });
-
-  it('uses exponential backoff delays', async () => {
-    const delays = [];
-    const onRetry = jest.fn((err, attempt, delay) => {
-      delays.push(delay);
-    });
-
-    const fn = jest.fn().mockRejectedValue(new Error('fail'));
-
-    await expect(
-      retry(fn, {
-        retries: 3,
-        baseDelay: 100,
-        factor: 2,
-        maxDelay: 1000,
-        onRetry,
-      })
-    ).rejects.toThrow();
-
-    // Delays should be: 100, 200, 400
-    expect(delays).toEqual([100, 200, 400]);
-  });
-
-  it('caps delay at maxDelay', async () => {
-    const delays = [];
-    const onRetry = jest.fn((err, attempt, delay) => {
-      delays.push(delay);
-    });
-
-    const fn = jest.fn().mockRejectedValue(new Error('fail'));
-
-    await expect(
-      retry(fn, {
-        retries: 3,
-        baseDelay: 100,
-        factor: 10,
-        maxDelay: 500,
-        onRetry,
-      })
-    ).rejects.toThrow();
-
-    // Delays: min(100, 500)=100, min(1000, 500)=500, min(10000, 500)=500
-    expect(delays).toEqual([100, 500, 500]);
-  });
-
-  it('passes attempt number to fn', async () => {
-    const attempts = [];
-    const fn = jest.fn().mockImplementation(async (attempt) => {
-      attempts.push(attempt);
-      if (attempt < 2) {
-        throw new Error('fail');
-      }
-      return 'ok';
-    });
-
-    await retry(fn, { retries: 3, baseDelay: 50 });
-    expect(attempts).toEqual([0, 1, 2]);
-  });
-});