markdown-to-slack-blocks 1.2.1 → 1.2.2

package/dist/splitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"splitter.d.ts","sourceRoot":"","sources":["../src/splitter.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,EAIR,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,kBAAkB;IAC/B,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAKD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,KAAK,EAAE,EAAE,CAkEpF"}
+{"version":3,"file":"splitter.d.ts","sourceRoot":"","sources":["../src/splitter.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,EAQR,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,kBAAkB;IAC/B,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAMD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,KAAK,EAAE,EAAE,CA6EpF"}

package/dist/splitter.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitBlocks = splitBlocks;
 const DEFAULT_MAX_BLOCKS = 40;
 const DEFAULT_MAX_CHARACTERS = 12000;
+const DEFAULT_MAX_TEXT_SECTION_CHARACTERS = 3000;
 /**
  * Splits an array of blocks into multiple arrays that fit within Slack's limits.
  * Attempts to split at natural boundaries (between top-level blocks, rich_text elements, etc.)
@@ -14,12 +15,24 @@ const DEFAULT_MAX_CHARACTERS = 12000;
 function splitBlocks(blocks, options) {
     const maxBlocks = options?.maxBlocks ?? DEFAULT_MAX_BLOCKS;
     const maxChars = options?.maxCharacters ?? DEFAULT_MAX_CHARACTERS;
-    if (blocks.length === 0) {
+    const normalizedBlocks = [];
+    for (const block of blocks) {
+        if (block.type === 'section') {
+            normalizedBlocks.push(...splitSectionBlock(block, DEFAULT_MAX_TEXT_SECTION_CHARACTERS));
+        }
+        else if (block.type === 'header') {
+            normalizedBlocks.push(...splitHeaderBlock(block, DEFAULT_MAX_TEXT_SECTION_CHARACTERS));
+        }
+        else {
+            normalizedBlocks.push(block);
+        }
+    }
+    if (normalizedBlocks.length === 0) {
         return [[]];
     }
     // Check if everything fits in one message
-    if (blocks.length <= maxBlocks && JSON.stringify(blocks).length <= maxChars) {
-        return [blocks];
+    if (normalizedBlocks.length <= maxBlocks && JSON.stringify(normalizedBlocks).length <= maxChars) {
+        return [normalizedBlocks];
     }
     const result = [];
     let currentBatch = [];
@@ -35,7 +48,7 @@ function splitBlocks(blocks, options) {
             currentBatch = [];
         }
     };
-    for (const block of blocks) {
+    for (const block of normalizedBlocks) {
         // Try to add block to current batch
         if (fitsInBatch(currentBatch, block)) {
             currentBatch.push(block);
@@ -198,3 +211,107 @@ function splitPreformattedElement(element, maxChars) {
     }
     return result.length > 0 ? result : [element];
 }
+/**
+ * Splits a large SectionBlock into multiple SectionBlocks if text exceeds limit
+ */
+function splitSectionBlock(block, maxChars) {
+    if (!block.text || block.text.text.length <= maxChars) {
+        return [block];
+    }
+    const chunks = chunkString(block.text.text, maxChars);
+    const result = [];
+    // The first block keeps the accessory and fields, subsequent ones are just text
+    chunks.forEach((chunk, index) => {
+        const newBlock = {
+            type: 'section',
+            text: {
+                ...block.text,
+                text: chunk
+            },
+            ...(block.block_id && index === 0 ? { block_id: block.block_id } : {})
+        };
+        if (index === 0) {
+            if (block.fields)
+                newBlock.fields = block.fields;
+            if (block.accessory)
+                newBlock.accessory = block.accessory;
+            // keep block_id only on first? Yes.
+        }
+        result.push(newBlock);
+    });
+    return result;
+}
+/**
+ * Splits a large HeaderBlock into multiple HeaderBlocks (or Header + Sections) if text exceeds limit
+ * Note: Headers are plain_text only.
+ */
+function splitHeaderBlock(block, maxChars) {
+    if (block.text.text.length <= maxChars) {
+        return [block];
+    }
+    const chunks = chunkString(block.text.text, maxChars);
+    const result = [];
+    // First chunk remains a header
+    result.push({
+        type: 'header',
+        text: {
+            ...block.text,
+            text: chunks[0]
+        },
+        ...(block.block_id ? { block_id: block.block_id } : {})
+    });
+    // Subsequent chunks become Section blocks
+    for (let i = 1; i < chunks.length; i++) {
+        result.push({
+            type: 'section',
+            text: {
+                type: 'mrkdwn',
+                text: chunks[i]
+            }
+        });
+    }
+    return result;
+}
+/**
+ * Helper to chunk string by character limit, trying to respect word boundaries
+ */
+function chunkString(str, limit) {
+    const chunks = [];
+    let current = str;
+    while (current.length > 0) {
+        if (current.length <= limit) {
+            chunks.push(current);
+            break;
+        }
+        // Take a slice of 'limit'
+        let sliceIndex = limit;
+        // Look for last newline within the safety zone (e.g. last 100 chars or just within the limit)
+        // We look backwards from limit.
+        const newlineIndex = current.lastIndexOf('\n', limit);
+        if (newlineIndex !== -1 && newlineIndex > 0) {
+            sliceIndex = newlineIndex; // Split AT newline (newline becomes part of first chunk? or consumed?)
+            // Usually split at newline means: "Line 1\nLine 2" -> "Line 1", "Line 2". 
+            // slice(0, index) excludes index.
+            // We want to keep the newline structure? 
+            // If we split "A\nB", chunk 1 "A", chunk 2 "B".
+            // So sliceIndex = newlineIndex.
+            // And next start = newlineIndex + 1.
+            chunks.push(current.slice(0, sliceIndex));
+            current = current.slice(sliceIndex + 1);
+            continue;
+        }
+        // Look for last space
+        const spaceIndex = current.lastIndexOf(' ', limit);
+        if (spaceIndex !== -1 && spaceIndex > limit * 0.8) { // Only split at space if it's somewhat close to the end, to avoid too short lines?
+            // Actually, any space is better than mid-word.
+            sliceIndex = spaceIndex;
+            chunks.push(current.slice(0, sliceIndex));
+            current = current.slice(sliceIndex + 1); // Skip the space
+            continue;
+        }
+        // Hard split
+        chunks.push(current.slice(0, limit));
+        current = current.slice(limit);
+    }
+    return chunks;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdown-to-slack-blocks",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Convert Markdown to Slack Block Kit JSON format",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",