shuvmaki 0.4.26

package/dist/escape-backticks.test.js

@@ -0,0 +1,410 @@
+import { test, expect } from 'vitest';
+import { Lexer } from 'marked';
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discord-utils.js';
+test('escapes single backticks in code blocks', () => {
+    const input = '```js\nconst x = `hello`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const x = \\\`hello\\\`
+\`\`\`
+"
+`);
+});
+test('escapes backticks in code blocks with language', () => {
+    const input = '```typescript\nconst greeting = `Hello, ${name}!`\nconst inline = `test`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`typescript
+const greeting = \\\`Hello, \${name}!\\\`
+const inline = \\\`test\\\`
+\`\`\`
+"
+`);
+});
+test('does not escape backticks outside code blocks', () => {
+    const input = 'This is `inline code` and this is a code block:\n```\nconst x = `template`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"This is \`inline code\` and this is a code block:
+\`\`\`
+const x = \\\`template\\\`
+\`\`\`
+"
+`);
+});
+test('handles multiple code blocks', () => {
+    const input = `First block:
+\`\`\`js
+const a = \`test\`
+\`\`\`
+
+Some text with \`inline\` code
+
+Second block:
+\`\`\`python
+name = f\`hello {world}\`
+\`\`\``;
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"First block:
+\`\`\`js
+const a = \\\`test\\\`
+\`\`\`
+
+
+Some text with \`inline\` code
+
+Second block:
+\`\`\`python
+name = f\\\`hello {world}\\\`
+\`\`\`
+"
+`);
+});
+test('handles code blocks without language', () => {
+    const input = '```\nconst x = `value`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`
+const x = \\\`value\\\`
+\`\`\`
+"
+`);
+});
+test('handles nested backticks in code blocks', () => {
+    const input = '```js\nconst nested = `outer ${`inner`} text`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const nested = \\\`outer \${\\\`inner\\\`} text\\\`
+\`\`\`
+"
+`);
+});
+test('preserves markdown outside code blocks', () => {
+    const input = `# Heading
+
+This is **bold** and *italic* text
+
+\`\`\`js
+const code = \`with template\`
+\`\`\`
+
+- List item 1
+- List item 2`;
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result).toMatchInlineSnapshot(`
+"# Heading
+
+This is **bold** and *italic* text
+
+\`\`\`js
+const code = \\\`with template\\\`
+\`\`\`
+
+
+- List item 1
+- List item 2"
+`);
+});
+test('does not escape code block delimiter backticks', () => {
+    const input = '```js\nconst x = `hello`\n```';
+    const result = escapeBackticksInCodeBlocks(input);
+    expect(result.startsWith('```')).toBe(true);
+    expect(result.endsWith('```\n')).toBe(true);
+    expect(result).toContain('\\`hello\\`');
+    expect(result).not.toContain('\\`\\`\\`js');
+    expect(result).not.toContain('\\`\\`\\`\n');
+    expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const x = \\\`hello\\\`
+\`\`\`
+"
+`);
+});
+test('splitMarkdownForDiscord returns single chunk for short content', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Hello world',
+        maxLength: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Hello world",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord splits at line boundaries', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Line 1\nLine 2\nLine 3\nLine 4',
+        maxLength: 15,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Line 1
+    Line 2
+    ",
+      "Line 3
+    Line 4",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord preserves code blocks when not split', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nconst x = 1\n```',
+        maxLength: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    const x = 1
+    \`\`\`",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord adds closing and opening fences when splitting code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nline1\nline2\nline3\nline4\n```',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    line1
+    line2
+    \`\`\`
+    ",
+      "\`\`\`js
+    line3
+    line4
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block with language', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```typescript\nconst a = 1\nconst b = 2\n```',
+        maxLength: 30,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`typescript
+    const a = 1
+    \`\`\`
+    ",
+      "\`\`\`typescript
+    const b = 2
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Text before\n```js\ncode\n```\nText after',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Text before
+    \`\`\`js
+    code
+    \`\`\`
+    ",
+      "Text after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block without language', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```\nline1\nline2\n```',
+        maxLength: 12,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`
+    line1
+    \`\`\`
+    ",
+      "\`\`\`
+    line2
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles multiple consecutive code blocks', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nfoo\n```\n```py\nbar\n```',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    foo
+    \`\`\`
+    \`\`\`py
+    \`\`\`
+    ",
+      "\`\`\`py
+    bar
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles empty code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'before\n```\n```\nafter',
+        maxLength: 50,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "before
+    \`\`\`
+    \`\`\`
+    after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles content exactly at maxLength', () => {
+    const result = splitMarkdownForDiscord({
+        content: '12345678901234567890',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "12345678901234567890",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block only', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```ts\nconst x = 1\n```',
+        maxLength: 15,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`ts
+    \`\`\`
+    ",
+      "\`\`\`ts
+    const x = 1
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block at start with text after', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\ncode\n```\nSome text after',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+      "Some text after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles text before code block at end', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Some text before\n```js\ncode\n```',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Some text before
+    \`\`\`js
+    \`\`\`
+    ",
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles very long line inside code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nshort\nveryverylonglinethatexceedsmaxlength\nshort\n```',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+      "\`\`\`js
+    veryverylonglinethatexceedsmaxlength
+    \`\`\`
+    ",
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles realistic long markdown with code block', () => {
+    const content = `Here is some explanation text before the code.
+
+\`\`\`typescript
+export function calculateTotal(items: Item[]): number {
+  let total = 0
+  for (const item of items) {
+    total += item.price * item.quantity
+  }
+  return total
+}
+
+export function formatCurrency(amount: number): string {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+  }).format(amount)
+}
+\`\`\`
+
+And here is some text after the code block.`;
+    const result = splitMarkdownForDiscord({
+        content,
+        maxLength: 200,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Here is some explanation text before the code.
+
+    \`\`\`typescript
+    export function calculateTotal(items: Item[]): number {
+      let total = 0
+      for (const item of items) {
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        total += item.price * item.quantity
+      }
+      return total
+    }
+
+    export function formatCurrency(amount: number): string {
+      return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        currency: 'USD',
+      }).format(amount)
+    }
+    \`\`\`
+
+
+    And here is some text after the code block.",
+    ]
+  `);
+});

package/dist/format-tables.js

@@ -0,0 +1,96 @@
+// Markdown table to code block converter.
+// Discord doesn't render GFM tables, so this converts them to
+// space-aligned code blocks for proper monospace display.
+import { Lexer } from 'marked';
+export function formatMarkdownTables(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'table') {
+            result += formatTableToken(token);
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}
+function formatTableToken(table) {
+    const headers = table.header.map((cell) => {
+        return extractCellText(cell.tokens);
+    });
+    const rows = table.rows.map((row) => {
+        return row.map((cell) => {
+            return extractCellText(cell.tokens);
+        });
+    });
+    const columnWidths = calculateColumnWidths(headers, rows);
+    const lines = [];
+    lines.push(formatRow(headers, columnWidths));
+    lines.push(formatSeparator(columnWidths));
+    for (const row of rows) {
+        lines.push(formatRow(row, columnWidths));
+    }
+    return '```\n' + lines.join('\n') + '\n```\n';
+}
+function extractCellText(tokens) {
+    const parts = [];
+    for (const token of tokens) {
+        parts.push(extractTokenText(token));
+    }
+    return parts.join('').trim();
+}
+function extractTokenText(token) {
+    switch (token.type) {
+        case 'text':
+        case 'codespan':
+        case 'escape':
+            return token.text;
+        case 'link':
+            return token.href;
+        case 'image':
+            return token.href;
+        case 'strong':
+        case 'em':
+        case 'del':
+            return token.tokens ? extractCellText(token.tokens) : token.text;
+        case 'br':
+            return ' ';
+        default: {
+            const tokenAny = token;
+            if (tokenAny.tokens && Array.isArray(tokenAny.tokens)) {
+                return extractCellText(tokenAny.tokens);
+            }
+            if (typeof tokenAny.text === 'string') {
+                return tokenAny.text;
+            }
+            return '';
+        }
+    }
+}
+function calculateColumnWidths(headers, rows) {
+    const widths = headers.map((h) => {
+        return h.length;
+    });
+    for (const row of rows) {
+        for (let i = 0; i < row.length; i++) {
+            const cell = row[i] ?? '';
+            widths[i] = Math.max(widths[i] ?? 0, cell.length);
+        }
+    }
+    return widths;
+}
+function formatRow(cells, widths) {
+    const paddedCells = cells.map((cell, i) => {
+        return cell.padEnd(widths[i] ?? 0);
+    });
+    return paddedCells.join(' ');
+}
+function formatSeparator(widths) {
+    return widths
+        .map((w) => {
+        return '-'.repeat(w);
+    })
+        .join(' ');
+}