@link-assistant/web-capture 1.7.20 → 1.7.22

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/web-capture
 
+## 1.7.22
+
+### Patch Changes
+
+- a339ca2: Fix `--capture api` collapsing `<br>`-separated lines inside list items into one run. The Google Docs export-html path lost line breaks when a `<br>` was the leading or trailing child of an inline element (e.g. a `<span>` between bold runs), because Turndown trims inner content of inline elements with edge whitespace. The HTML pre-processing now hoists those edge `<br>`s out of their inline parents before Turndown sees them, restoring CommonMark hard breaks. Additionally, the post-processor's double-space collapse no longer eats the two trailing spaces that mark a hard break.
+
+## 1.7.21
+
+### Patch Changes
+
+- b8ad97d: Number consecutive top-level `<ol>`s continuously across the document (1, 2, 3, ... N) so JS and Rust HTML→Markdown converters agree. `<ol start="N">` resets the counter and is honoured by both implementations. Nested ordered lists keep their own per-list numbering.
+
 ## 1.7.20
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/web-capture",
-  "version": "1.7.20",
+  "version": "1.7.22",
   "description": "CLI and microservice to render web pages as HTML, Markdown, or PNG",
   "main": "src/index.js",
   "bin": {

package/src/gdocs-preprocess.js

@@ -245,6 +245,12 @@ function renderNestedListGroup($, group, classStyles) {
   const openTags = [];
   const itemOpen = [];
 
+  const topLevelStart =
+    group[0]?.tagName?.toLowerCase() === 'ol'
+      ? $(group[0]).attr('start')
+      : undefined;
+  let topLevelOpened = false;
+
   const closeItem = (level) => {
     if (itemOpen[level]) {
       html += '</li>';
@@ -261,7 +267,21 @@ function renderNestedListGroup($, group, classStyles) {
   const openList = (level, tagName) => {
     openTags[level] = tagName;
     itemOpen[level] = false;
-    html += `<${tagName}>`;
+    if (
+      level === 0 &&
+      !topLevelOpened &&
+      tagName === 'ol' &&
+      topLevelStart !== undefined &&
+      topLevelStart !== ''
+    ) {
+      html += `<ol start="${topLevelStart}">`;
+      topLevelOpened = true;
+    } else {
+      if (level === 0) {
+        topLevelOpened = true;
+      }
+      html += `<${tagName}>`;
+    }
   };
 
   for (const list of group) {

package/src/lib.js

@@ -59,6 +59,10 @@ export function convertHtmlToMarkdown(html, baseUrl) {
   //    Demoting avoids ATX heading prefix, leaving the sub-number on a clean line.
   preserveLeadingHeadingNumbering($);
 
+  // Number consecutive top-level <ol>s continuously across the document
+  // (1, 2, 3 ... N) so JS and Rust agree. <ol start="N"> resets the counter.
+  applyContinuousOrderedListNumbering($);
+
   // Remove <a> tags with no direct text content (including only whitespace or only child elements)
   $('a').each(function () {
     // Get all text nodes directly under this <a>
@@ -160,6 +164,10 @@ export function convertHtmlToMarkdown(html, baseUrl) {
     $table.replaceWith($newTable);
   });
 
+  // Hoist <br>s out of inline edges so Turndown's flanking-whitespace trim
+  // does not eat the hard break. See liftBrFromInlineEdges for details.
+  liftBrFromInlineEdges($);
+
   // Convert cleaned HTML to Markdown
   const turndown = new TurndownService({
     headingStyle: 'atx',
@@ -179,6 +187,72 @@ export function convertHtmlToMarkdown(html, baseUrl) {
   return he.decode(turndown.turndown($.html())).replace(/\u00A0/g, '&nbsp;');
 }
 
+// Lift <br> nodes out of inline parents when they sit at the leading or
+// trailing edge.
+//
+// Turndown calls `content.trim()` on the inner markdown of any inline element
+// whose `flankingWhitespace` is non-empty (turndown.cjs.js:902), which strips
+// the `  \n` hard break that the <br> rule emits. Google Docs export-html
+// commonly produces `<strong>X</strong><span> Y.<br></span><strong>Z</strong>`
+// — the trailing <br> inside a leading-space <span> gets `.trim()`-ed away,
+// so X/Y/Z collapse onto one line.
+//
+// Hoisting trailing/leading <br>s out of their inline wrapper sidesteps the
+// trim entirely. The hard break then attaches at the parent level, which
+// Turndown handles correctly.
+function liftBrFromInlineEdges($) {
+  const inlineParents = new Set([
+    'span',
+    'a',
+    'strong',
+    'b',
+    'em',
+    'i',
+    'u',
+    's',
+    'del',
+    'ins',
+    'sub',
+    'sup',
+    'mark',
+    'small',
+    'q',
+    'cite',
+    'code',
+    'abbr',
+    'time',
+    'kbd',
+    'samp',
+    'var',
+    'font',
+  ]);
+
+  // Hoist <br>s repeatedly until none sit at an inline edge — this handles
+  // nested wrappers like `<span><em>foo<br></em></span>`.
+  let changed = true;
+  while (changed) {
+    changed = false;
+    $('br').each(function () {
+      const el = this;
+      const parent = el.parent;
+      if (!parent || !inlineParents.has(parent.tagName)) {
+        return;
+      }
+      const isFirst = parent.children[0] === el;
+      const isLast = parent.children[parent.children.length - 1] === el;
+      if (!isFirst && !isLast) {
+        return;
+      }
+      if (isLast) {
+        $(parent).after(el);
+      } else {
+        $(parent).before(el);
+      }
+      changed = true;
+    });
+  }
+}
+
 function preserveLeadingHeadingNumbering($) {
   // Hoist the OL counter onto a heading inside its first <li>.
   // Example: <ol><li><h4>13. Foo</h4></li></ol> → <ol start="13"><li><h4>Foo</h4></li></ol>
@@ -228,6 +302,28 @@ function preserveLeadingHeadingNumbering($) {
   });
 }
 
+// Walk every top-level <ol> in document order and assign a `start` attribute
+// so consecutive lists number continuously (1, 2, 3, ... N). An explicit
+// `start="N"` resets the running counter to N and is preserved.
+//
+// Top-level here means "not inside another <ol> or <ul>" — nested ordered
+// lists keep their own numbering and Turndown's per-list start handling.
+function applyContinuousOrderedListNumbering($) {
+  let counter = 1;
+  $('ol').each(function () {
+    if ($(this).parents('ol, ul').length > 0) {
+      return;
+    }
+    const explicitStart = parseInt($(this).attr('start') ?? '', 10);
+    if (Number.isFinite(explicitStart)) {
+      counter = explicitStart;
+    } else {
+      $(this).attr('start', String(counter));
+    }
+    counter += $(this).children('li').length;
+  });
+}
+
 function stripLeadingTextFromHeading($, $heading, prefixLen) {
   // Walk text nodes from the start of the heading and remove prefixLen characters.
   let remaining = prefixLen;
@@ -506,6 +602,9 @@ export function convertHtmlToMarkdownEnhanced(html, baseUrl, options = {}) {
   // Preserve hierarchical heading numbering (see convertHtmlToMarkdown).
   preserveLeadingHeadingNumbering($);
 
+  // Continuous numbering across consecutive top-level <ol>s (see convertHtmlToMarkdown).
+  applyContinuousOrderedListNumbering($);
+
   // Remove empty links (same logic as convertHtmlToMarkdown)
   $('a').each(function () {
     const directText = $(this)
@@ -645,6 +744,9 @@ export function convertHtmlToMarkdownEnhanced(html, baseUrl, options = {}) {
     $table.replaceWith($newTable);
   });
 
+  // Hoist <br>s out of inline edges (see liftBrFromInlineEdges).
+  liftBrFromInlineEdges($);
+
   // Convert to Markdown using Turndown
   const turndown = new TurndownService({
     headingStyle: 'atx',

package/src/postprocess.js

@@ -50,8 +50,9 @@ export function postProcessMarkdown(markdown, options = {}) {
     result = applyBoldFormattingFixes(result);
   }
 
-  // Fix double spaces (but not in code blocks)
-  result = result.replace(/([^\n`]) +/g, (match, char) => `${char} `);
+  // Fix double spaces (but not in code blocks, and preserve CommonMark hard
+  // breaks which require two trailing spaces before a newline).
+  result = result.replace(/([^\n`]) +(?!\n)/g, (match, char) => `${char} `);
 
   // Clean up extra spaces around em-dashes
   result = result.replace(/\s+—\s+/g, ' — ');

package/tests/fixtures/list-item-with-br.html

@@ -0,0 +1,8 @@
+<ol>
+  <li>
+    <strong>Glossary entry.</strong><span> Some lead text.<br /></span
+    ><strong>TAG1</strong><span> – Definition one.<br /></span
+    ><strong>TAG2</strong><span> – Definition two.<br /></span
+    ><strong>TAG3</strong><span> – Definition three.</span>
+  </li>
+</ol>

package/tests/fixtures/ol-continuous-numbering.html

@@ -0,0 +1,12 @@
+<ol>
+  <li><strong>First</strong></li>
+  <li><strong>Second</strong></li>
+</ol>
+<p>Some prose between lists.</p>
+<ol>
+  <li><strong>Third</strong></li>
+  <li><strong>Fourth</strong></li>
+</ol>
+<ol start="13">
+  <li><strong>Top-level numbered heading.</strong></li>
+</ol>

package/tests/unit/html2md-br-in-list-item.test.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { convertHtmlToMarkdown } from '../../src/lib.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const HTML = fs.readFileSync(
+  path.join(__dirname, '..', 'fixtures', 'list-item-with-br.html'),
+  'utf8'
+);
+
+it('preserves <br> as a line separator inside list items', () => {
+  const md = convertHtmlToMarkdown(HTML);
+  for (const tag of ['TAG1', 'TAG2', 'TAG3']) {
+    expect(md).toMatch(
+      new RegExp(`(^|\\n)\\s*\\*{0,2}${tag}\\*{0,2}\\s*–`, 'm')
+    );
+  }
+  // Definitions must not be glued on the same line (no <br> dropped).
+  expect(md).not.toMatch(/Definition one\.[ \t]*\*{0,2}TAG2/);
+  expect(md).not.toMatch(/Definition two\.[ \t]*\*{0,2}TAG3/);
+});

package/tests/unit/html2md-ol-numbering.test.js

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { convertHtmlToMarkdown } from '../../src/lib.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const HTML = fs.readFileSync(
+  path.join(__dirname, '..', 'fixtures', 'ol-continuous-numbering.html'),
+  'utf8'
+);
+
+it('numbers consecutive top-level ordered lists continuously', () => {
+  const md = convertHtmlToMarkdown(HTML);
+  expect(md).toMatch(/^\s*1\.\s+\*\*First\*\*/m);
+  expect(md).toMatch(/^\s*2\.\s+\*\*Second\*\*/m);
+  expect(md).toMatch(/^\s*3\.\s+\*\*Third\*\*/m);
+  expect(md).toMatch(/^\s*4\.\s+\*\*Fourth\*\*/m);
+  expect(md).toMatch(/^\s*13\.\s+\*\*Top-level/m);
+});