svelte-streamdown 4.0.1 → 4.1.0

package/dist/utils/table-export.js

@@ -0,0 +1,82 @@
+// textContent flattens a real <br> element, so a multiline cell collapses to
+// 'Paragraph one.Paragraph two.'. Walk the cell instead and keep the breaks;
+// the serializers below quote or escape them.
+const extractCellText = (node) => {
+    if (node.nodeType === 3)
+        return node.textContent || '';
+    if (node.tagName === 'BR')
+        return '\n';
+    return Array.from(node.childNodes).map(extractCellText).join('');
+};
+/**
+ * Read a rendered table (or any element containing one) into a plain matrix.
+ * `colspan`/`rowspan` are expanded into empty cells so every row lines up.
+ */
+export const extractTableData = (element) => {
+    const trs = Array.from(element.querySelectorAll('tr'));
+    const rowSpanFills = [];
+    const matrix = trs.map((row, rowIndex) => {
+        const rowData = [];
+        let actualCol = 0; // column position in the output matrix, not in the DOM row
+        Array.from(row.querySelectorAll('td, th')).forEach((cell) => {
+            const colSpan = parseInt(cell.getAttribute('colspan') || '1');
+            const rowSpan = parseInt(cell.getAttribute('rowspan') || '1');
+            rowData.push(extractCellText(cell));
+            for (let i = 0; i < colSpan - 1; i++) {
+                rowData.push('');
+            }
+            if (rowSpan > 1) {
+                for (let r = 1; r < rowSpan; r++) {
+                    rowSpanFills.push({ rowIndex: rowIndex + r, colIndex: actualCol, colSpan });
+                }
+            }
+            actualCol += colSpan;
+        });
+        return rowData;
+    });
+    rowSpanFills.forEach(({ rowIndex, colIndex, colSpan }) => {
+        if (matrix[rowIndex]) {
+            matrix[rowIndex].splice(colIndex, 0, ...Array(colSpan).fill(''));
+        }
+    });
+    // A markdown table always renders exactly one <thead> row; a DOM-only caller
+    // may hand us a table without one, and then everything is a data row.
+    const headers = trs[0]?.closest('thead') ? (matrix.shift() ?? []) : [];
+    return { headers, rows: matrix };
+};
+const allRows = ({ headers, rows }) => (headers.length ? [headers, ...rows] : rows);
+// Spreadsheets in locales that write 1,1 for one-and-a-tenth read ';' as the
+// column separator; Intl is the only locale source we have without a dependency.
+const resolveSeparator = (separator) => separator === 'auto' ? (Intl.NumberFormat().format(1.1).includes(',') ? ';' : ',') : separator;
+export const tableDataToCSV = (data, separator = ',') => {
+    const sep = resolveSeparator(separator);
+    const escape = (value) => value.includes(sep) || /["\n\r]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+    return allRows(data)
+        .map((row) => row.map(escape).join(sep))
+        .join('\n');
+};
+export const tableDataToTSV = (data) => {
+    // TSV has no quoting, so a tab or a break inside a cell has to become an escape.
+    const escape = (value) => value.replace(/\t/g, '\\t').replace(/\r/g, '\\r').replace(/\n/g, '\\n');
+    return allRows(data)
+        .map((row) => row.map(escape).join('\t'))
+        .join('\n');
+};
+export const tableDataToMarkdown = (data) => {
+    const { headers, rows } = data;
+    if (headers.length === 0)
+        return '';
+    // Backslashes first: escaping pipes adds backslashes of its own.
+    const escape = (cell) => cell.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/\n/g, '<br>');
+    const line = (cells) => `| ${headers.map((_, i) => escape(cells[i] ?? '')).join(' | ')} |`;
+    return [line(headers), `| ${headers.map(() => '---').join(' | ')} |`, ...rows.map(line)].join('\n');
+};
+export const tableDataToHTML = (data) => {
+    const escape = (cell) => cell.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\n/g, '<br>');
+    const row = (cells, tag) => `<tr>${cells.map((cell) => `<${tag}>${escape(cell)}</${tag}>`).join('')}</tr>`;
+    const head = data.headers.length ? `<thead>${row(data.headers, 'th')}</thead>` : '';
+    const body = data.rows.length
+        ? `<tbody>${data.rows.map((r) => row(r, 'td')).join('')}</tbody>`
+        : '';
+    return `<table>${head}${body}</table>`;
+};

package/dist/utils/usePinnedScroll.svelte.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The whole pin/unpin decision, kept pure so it can be tested without a DOM.
+ * The user scrolling away from the bottom is what unpins; scrolling back pins
+ * again. There is no separate latch: "was the user at the bottom last time they
+ * scrolled" is the latch.
+ */
+export declare const isAtBottom: (scrollTop: number, scrollHeight: number, clientHeight: number) => boolean;
+export interface PinnedScrollOptions {
+    /** The resolved max-height; pinning is off (and costs nothing) without one. */
+    readonly maxHeight: string | undefined;
+    /** Anything that changes when the content grows — re-runs the scroll. */
+    readonly content: unknown;
+}
+/**
+ * Attachment that keeps a capped scroll container stuck to the bottom while its
+ * content grows, unless the user has scrolled up.
+ *
+ * Scrolling is always instant: this fires on every streamed chunk, so a smooth
+ * animation would never finish before the next one starts (and would ignore
+ * `prefers-reduced-motion`).
+ */
+export declare const usePinnedScroll: (options: PinnedScrollOptions) => (node: HTMLElement) => (() => void) | undefined;

package/dist/utils/usePinnedScroll.svelte.js

@@ -0,0 +1,36 @@
+import { on } from 'svelte/events';
+// A scroll position this close to the bottom counts as "at the bottom": browsers
+// report fractional scrollTop on zoomed/hi-dpi displays, so an exact compare
+// would unpin the container on its own.
+const BOTTOM_THRESHOLD_PX = 8;
+/**
+ * The whole pin/unpin decision, kept pure so it can be tested without a DOM.
+ * The user scrolling away from the bottom is what unpins; scrolling back pins
+ * again. There is no separate latch: "was the user at the bottom last time they
+ * scrolled" is the latch.
+ */
+export const isAtBottom = (scrollTop, scrollHeight, clientHeight) => scrollHeight - scrollTop - clientHeight < BOTTOM_THRESHOLD_PX;
+/**
+ * Attachment that keeps a capped scroll container stuck to the bottom while its
+ * content grows, unless the user has scrolled up.
+ *
+ * Scrolling is always instant: this fires on every streamed chunk, so a smooth
+ * animation would never finish before the next one starts (and would ignore
+ * `prefers-reduced-motion`).
+ */
+export const usePinnedScroll = (options) => {
+    return (node) => {
+        if (!options.maxHeight)
+            return;
+        let pinned = true;
+        const off = on(node, 'scroll', () => {
+            pinned = isAtBottom(node.scrollTop, node.scrollHeight, node.clientHeight);
+        }, { passive: true });
+        $effect(() => {
+            options.content;
+            if (pinned)
+                node.scrollTop = node.scrollHeight;
+        });
+        return off;
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-streamdown",
-	"version": "4.0.1",
+	"version": "4.1.0",
 	"packageManager": "pnpm@10.32.1",
 	"repository": {
 		"type": "git",
@@ -23,7 +23,8 @@
 		"test:ui": "vitest --ui",
 		"test:unit": "vitest",
 		"test:browser": "vitest --run --project client",
-		"test": "npm run test:unit -- --run --project server"
+		"test": "npm run test:unit -- --run --project server",
+		"test:size": "vitest --run --project server src/tests/bundle-size.test.ts"
 	},
 	"files": [
 		"dist",