@elastic/isomer-sdk 0.0.0 → 0.2.0

package/dist/cjs/render/slack/blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.js","sourceRoot":"","sources":["../../../../src/render/slack/blocks.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AA6CH;;;GAGG;AACU,QAAA,YAAY,GAAG;IAC1B,gBAAgB,EAAE,EAAE;IACpB,sBAAsB;IACtB,gBAAgB,EAAE,IAAI;IACtB,qCAAqC;IACrC,iBAAiB,EAAE,IAAI;IACvB,uCAAuC;IACvC,mBAAmB,EAAE,IAAI;IACzB,4CAA4C;IAC5C,eAAe,EAAE,GAAG;IACpB,gBAAgB,EAAE,EAAE;IACpB,oCAAoC;IACpC,eAAe,EAAE,EAAE;IACnB,iBAAiB,EAAE,EAAE;IACrB,kFAAkF;IAClF,iBAAiB,EAAE,IAAI;IACvB,yEAAyE;IACzE,eAAe,EAAE,EAAE;IACnB,sDAAsD;IACtD,gBAAgB,EAAE,GAAG;IACrB,4DAA4D;IAC5D,kBAAkB,EAAE,CAAC;IACrB,4DAA4D;IAC5D,gBAAgB,EAAE,EAAE;IACpB,+EAA+E;IAC/E,qBAAqB,EAAE,GAAG;IAC1B,yDAAyD;IACzD,gBAAgB,EAAE,GAAG;IACrB,0BAA0B;IAC1B,gBAAgB,EAAE,IAAI;IACtB,6CAA6C;IAC7C,QAAQ,EAAE,IAAI;IACd,4CAA4C;IAC5C,aAAa,EAAE,GAAG;IAClB,6CAA6C;IAC7C,qBAAqB,EAAE,CAAC;IACxB;;;;;OAKG;IACH,wBAAwB,EAAE,MAAM;IAChC,wDAAwD;IACxD,SAAS,EAAE,GAAG;IACd,iDAAiD;IACjD,YAAY,EAAE,EAAE;IAChB,oDAAoD;IACpD,aAAa,EAAE,IAAI;IACnB,mDAAmD;IACnD,iBAAiB,EAAE,IAAI;IACvB,6BAA6B;IAC7B,eAAe,EAAE,IAAI;IACrB,4DAA4D;IAC5D,eAAe,EAAE,GAAG;IACpB,kEAAkE;IAClE,qBAAqB,EAAE,GAAG;IAC1B,iEAAiE;IACjE,oBAAoB,EAAE,EAAE;IACxB,+BAA+B;IAC/B,eAAe,EAAE,EAAE;IACnB,4BAA4B;IAC5B,gBAAgB,EAAE,GAAG;IACrB,+BAA+B;IAC/B,qBAAqB,EAAE,EAAE;CACjB,CAAC","sourcesContent":["/*\n * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one\n * or more contributor license agreements. Licensed under the Elastic License\n * 2.0; you may not use this file except in compliance with the Elastic License\n * 2.0.\n */\n\nexport type {\n  SlackActionElement,\n  SlackActionsBlock,\n  SlackBlock,\n  SlackButtonElement,\n  SlackCheckboxesElement,\n  SlackContextBlock,\n  SlackDividerBlock,\n  SlackFileReference,\n  SlackHeaderBlock,\n  SlackHeaderLevel,\n  SlackImageBlock,\n  SlackImageElement,\n  SlackMrkdwnTextObject,\n  SlackMultiStaticSelectElement,\n  SlackOptionGroup,\n  SlackOptionObject,\n  SlackOverflowElement,\n  SlackPlainTextObject,\n  SlackRadioButtonsElement,\n  SlackRawTextElement,\n  SlackRichTextBlock,\n  SlackRichTextBlockElement,\n  SlackRichTextInline,\n  SlackRichTextLink,\n  SlackRichTextList,\n  SlackRichTextPreformatted,\n  SlackRichTextQuote,\n  SlackRichTextSection,\n  SlackRichTextStyle,\n  SlackRichTextTag,\n  SlackRichTextText,\n  SlackSectionAccessory,\n  SlackSectionBlock,\n  SlackStaticSelectElement,\n  SlackTableBlock,\n  SlackTableCell,\n  SlackTableColumnSetting,\n  SlackTagColor,\n  SlackTextObject,\n  SlackVideoBlock,\n} from '../../define/slack_blocks';\n\n/**\n * Slack's published surface limits, enforced by the renderer so a composition\n * cannot silently trip Slack's validation.\n */\nexport const SLACK_LIMITS = {\n  blocksPerMessage: 50,\n  /** `section.text`. */\n  sectionTextChars: 3000,\n  /** One entry of `section.fields`. */\n  sectionFieldChars: 2000,\n  /** One entry of `context.elements`. */\n  contextElementChars: 2000,\n  /** `header.text`, which is `plain_text`. */\n  headerTextChars: 150,\n  fieldsPerSection: 10,\n  /** Elements per `context` block. */\n  contextElements: 10,\n  buttonsPerActions: 25,\n  /** Slack truncates the top-level `text` fallback in notifications around here. */\n  fallbackTextChars: 4000,\n  /** `plain_text` option labels (selects, radio, checkboxes, overflow). */\n  optionTextChars: 75,\n  /** Options per select, or per option group of one. */\n  optionsPerSelect: 100,\n  /** Options per overflow menu (Slack caps overflow at 5). */\n  optionsPerOverflow: 5,\n  /** Options per radio button group or checkboxes element. */\n  optionsPerChoice: 10,\n  /** Option groups per select, each holding up to `optionsPerSelect` options. */\n  optionGroupsPerSelect: 100,\n  /** An option's `value`, which interactions send back. */\n  optionValueChars: 150,\n  /** A button's `value`. */\n  buttonValueChars: 2000,\n  /** A button's or overflow option's `url`. */\n  urlChars: 3000,\n  /** An interactive element's `action_id`. */\n  actionIdChars: 255,\n  /** Max indent level for `rich_text_list`. */\n  richTextListMaxIndent: 8,\n  /**\n   * Characters across every table cell in one message. Slack publishes the\n   * same 10,000 figure per table and per message, so the message-wide\n   * aggregate is the binding one.\n   * https://docs.slack.dev/reference/block-kit/blocks/table-block/\n   */\n  tableCellCharsPerMessage: 10_000,\n  /** Rows per `table` block (includes the header row). */\n  tableRows: 100,\n  /** Cells per `table` row / columns per table. */\n  tableColumns: 20,\n  /** `image`/image-element `image_url` max length. */\n  imageUrlChars: 3000,\n  /** `image`/image-element `alt_text` max length. */\n  imageAltTextChars: 2000,\n  /** `image` block `title`. */\n  imageTitleChars: 2000,\n  /** `video` block `title`; Slack requires fewer than 200. */\n  videoTitleChars: 199,\n  /** `video` block `description`; Slack requires fewer than 200. */\n  videoDescriptionChars: 199,\n  /** `video` block `author_name`; Slack requires fewer than 50. */\n  videoAuthorNameChars: 49,\n  /** `button` element `text`. */\n  buttonTextChars: 75,\n  /** Select `placeholder`. */\n  placeholderChars: 150,\n  /** `option_groups[].label`. */\n  optionGroupLabelChars: 75,\n} as const;\n"]}

package/dist/cjs/render/slack/envelope.js

@@ -0,0 +1,551 @@
+"use strict";
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0; you may not use this file except in compliance with the Elastic License
+ * 2.0.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSlackEnvelope = void 0;
+const envelope_1 = require("../text/envelope");
+const assets_1 = require("./assets");
+const blocks_1 = require("./blocks");
+const format_1 = require("./format");
+/**
+ * The composition as a `chat.postMessage` payload: notification `text`, blocks,
+ * and the images the host must upload first.
+ *
+ * Degradation for a node with no `slack` renderer is the dispatcher's, which
+ * has to own it to reach a child nested inside a container. The result is
+ * fitted to Slack's limits — text is clamped, blocks past a count limit and
+ * `rich_text` elements past a section's limit split, tables past a table limit
+ * or the message's cell budget become rich text, spacers and then whole blocks
+ * are dropped — so the output is always postable. `assets` stays empty
+ * unless `collectAssets` is set.
+ */
+const renderSlackEnvelope = (composition, dispatcher, options = {}) => {
+    const blocks = [];
+    // The collector is opt-in: without it, charts keep their markdown/text
+    // degradation and non-reachable images degrade to a link/text section, so
+    // default output is safe for callers that cannot upload files.
+    const collector = options.collectAssets
+        ? (0, assets_1.createSlackAssetCollector)(options.assetPrefix === undefined ? {} : { prefix: options.assetPrefix })
+        : undefined;
+    const { heading = true } = options;
+    if (heading && composition.title) {
+        blocks.push(headerBlock(composition.title, 1));
+    }
+    if (heading && composition.subtitle) {
+        blocks.push(contextBlock([(0, format_1.escapeMrkdwn)(composition.subtitle)]));
+    }
+    for (const node of composition.body) {
+        blocks.push(...dispatcher.renderSlack(node, collector).flatMap(fitBlock));
+    }
+    // Split after the rhythm, so the fragments of one block read as one.
+    const rhythm = applySectionRhythm(coalesceFieldSections(enforceTableLimits(blocks))).flatMap(splitBlockCounts);
+    const budgeted = enforceBlockBudget(rhythm);
+    // Only ask the host to upload assets whose placeholder block survived the
+    // budget; blocks elided by `enforceBlockBudget` are never posted, so
+    // uploading their files would be wasted (and orphaned) work.
+    const keptRefs = collectSlackFileRefs(budgeted);
+    return {
+        text: (0, format_1.clampMrkdwn)(options.text ??
+            (0, format_1.escapeMrkdwn)((0, envelope_1.renderTextEnvelope)(composition, dispatcher, { heading })), blocks_1.SLACK_LIMITS.fallbackTextChars),
+        blocks: budgeted,
+        assets: collector
+            ? collector.requests.filter((request) => keptRefs.has(request.ref))
+            : [],
+    };
+};
+exports.renderSlackEnvelope = renderSlackEnvelope;
+const clampText = (text, max) => text.text.length <= max
+    ? text
+    : {
+        ...text,
+        text: (text.type === 'mrkdwn' ? format_1.clampMrkdwn : format_1.clampSlackText)(text.text, max),
+    };
+const fitsImageUrl = ({ image_url }) => image_url === undefined || image_url.length <= blocks_1.SLACK_LIMITS.imageUrlChars;
+const clampAlt = (image) => image.alt_text.length <= blocks_1.SLACK_LIMITS.imageAltTextChars
+    ? image
+    : {
+        ...image,
+        alt_text: (0, format_1.clampSlackText)(image.alt_text, blocks_1.SLACK_LIMITS.imageAltTextChars),
+    };
+// A cut URL would point somewhere else, so one past the limit is dropped.
+const withoutLongUrl = (element) => {
+    if (element.url === undefined ||
+        element.url.length <= blocks_1.SLACK_LIMITS.urlChars) {
+        return element;
+    }
+    const { url: _dropped, ...rest } = element;
+    return rest;
+};
+const optionValue = (value) => (0, format_1.cutSlackValue)(value, blocks_1.SLACK_LIMITS.optionValueChars);
+const clampOption = (option) => withoutLongUrl({
+    ...option,
+    text: clampText(option.text, blocks_1.SLACK_LIMITS.optionTextChars),
+    value: optionValue(option.value),
+    ...(option.description && {
+        description: clampText(option.description, blocks_1.SLACK_LIMITS.optionTextChars),
+    }),
+});
+const clampControl = (element) => {
+    const actionId = element.action_id === undefined
+        ? {}
+        : {
+            action_id: (0, format_1.cutSlackValue)(element.action_id, blocks_1.SLACK_LIMITS.actionIdChars),
+        };
+    if (element.type === 'button') {
+        return withoutLongUrl({
+            ...element,
+            ...actionId,
+            text: clampText(element.text, blocks_1.SLACK_LIMITS.buttonTextChars),
+            ...(element.value !== undefined && {
+                value: (0, format_1.cutSlackValue)(element.value, blocks_1.SLACK_LIMITS.buttonValueChars),
+            }),
+        });
+    }
+    const menu = { ...element, ...actionId };
+    const maxOptions = menu.type === 'overflow'
+        ? blocks_1.SLACK_LIMITS.optionsPerOverflow
+        : menu.type === 'radio_buttons' || menu.type === 'checkboxes'
+            ? blocks_1.SLACK_LIMITS.optionsPerChoice
+            : blocks_1.SLACK_LIMITS.optionsPerSelect;
+    if (menu.options) {
+        menu.options = menu.options.slice(0, maxOptions).map(clampOption);
+    }
+    if ('placeholder' in menu && menu.placeholder) {
+        menu.placeholder = clampText(menu.placeholder, blocks_1.SLACK_LIMITS.placeholderChars);
+    }
+    if ('option_groups' in menu && menu.option_groups) {
+        menu.option_groups = menu.option_groups
+            .slice(0, blocks_1.SLACK_LIMITS.optionGroupsPerSelect)
+            .map((group) => ({
+            ...group,
+            label: clampText(group.label, blocks_1.SLACK_LIMITS.optionGroupLabelChars),
+            options: group.options.slice(0, maxOptions).map(clampOption),
+        }));
+    }
+    // Slack requires an initial option to equal one it emits, so each is
+    // replaced by the emitted option of the same value, or dropped.
+    const emitted = new Map([
+        ...(menu.options ?? []),
+        ...(('option_groups' in menu && menu.option_groups) || []).flatMap(({ options }) => options),
+    ].map((option) => [option.value, option]));
+    if ('initial_option' in menu && menu.initial_option) {
+        const match = emitted.get(optionValue(menu.initial_option.value));
+        if (match) {
+            menu.initial_option = match;
+        }
+        else {
+            delete menu.initial_option;
+        }
+    }
+    if ('initial_options' in menu && menu.initial_options) {
+        const matches = menu.initial_options.flatMap(({ value }) => {
+            const match = emitted.get(optionValue(value));
+            return match ? [match] : [];
+        });
+        if (matches.length > 0) {
+            menu.initial_options = matches;
+        }
+        else {
+            delete menu.initial_options;
+        }
+    }
+    return menu;
+};
+const chunks = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, index) => items.slice(index * size, (index + 1) * size));
+// Splits a block past a count limit into blocks of its type. Only the first
+// keeps a `block_id`, which Slack requires to be unique.
+const splitBlockCounts = (block) => {
+    switch (block.type) {
+        case 'context':
+            return chunks(block.elements, blocks_1.SLACK_LIMITS.contextElements).map((elements, index) => index === 0 ? { ...block, elements } : { type: 'context', elements });
+        case 'actions':
+            return chunks(block.elements, blocks_1.SLACK_LIMITS.buttonsPerActions).map((elements, index) => index === 0 ? { ...block, elements } : { type: 'actions', elements });
+        case 'section': {
+            if (!block.fields ||
+                block.fields.length <= blocks_1.SLACK_LIMITS.fieldsPerSection) {
+                return [block];
+            }
+            return chunks(block.fields, blocks_1.SLACK_LIMITS.fieldsPerSection).map((fields, index) => index === 0 ? { ...block, fields } : { type: 'section', fields });
+        }
+        default:
+            return [block];
+    }
+};
+// An image whose URL Slack would reject leaves its alt text.
+const fitImageUrls = (block) => {
+    switch (block.type) {
+        case 'image':
+            return fitsImageUrl(block)
+                ? [block]
+                : block.alt_text
+                    ? [contextBlock([(0, format_1.escapeMrkdwn)(block.alt_text)])]
+                    : [];
+        case 'context':
+            return [
+                {
+                    ...block,
+                    elements: block.elements.flatMap((element) => element.type !== 'image' || fitsImageUrl(element)
+                        ? [element]
+                        : element.alt_text
+                            ? [{ type: 'mrkdwn', text: (0, format_1.escapeMrkdwn)(element.alt_text) }]
+                            : []),
+                },
+            ];
+        case 'section': {
+            if (block.accessory?.type !== 'image' || fitsImageUrl(block.accessory)) {
+                return [block];
+            }
+            const { accessory, ...rest } = block;
+            return accessory.alt_text
+                ? [rest, contextBlock([(0, format_1.escapeMrkdwn)(accessory.alt_text)])]
+                : [rest];
+        }
+        default:
+            return [block];
+    }
+};
+const fitBlock = (block) => fitImageUrls(block).map(clampBlockText);
+// Pack renderers build their own blocks, and one overlong text makes Slack
+// reject the whole message.
+const clampBlockText = (block) => {
+    switch (block.type) {
+        case 'header':
+            return {
+                ...block,
+                text: clampText(block.text, blocks_1.SLACK_LIMITS.headerTextChars),
+            };
+        case 'section':
+            return {
+                ...block,
+                ...(block.text && {
+                    text: clampText(block.text, blocks_1.SLACK_LIMITS.sectionTextChars),
+                }),
+                ...(block.fields && {
+                    fields: block.fields.map((field) => clampText(field, blocks_1.SLACK_LIMITS.sectionFieldChars)),
+                }),
+                ...(block.accessory && {
+                    accessory: block.accessory.type === 'image'
+                        ? clampAlt(block.accessory)
+                        : clampControl(block.accessory),
+                }),
+            };
+        case 'rich_text':
+            return {
+                ...block,
+                elements: block.elements.flatMap(splitRichTextElement),
+            };
+        case 'context':
+            return {
+                ...block,
+                elements: block.elements.map((element) => element.type === 'image'
+                    ? clampAlt(element)
+                    : clampText(element, blocks_1.SLACK_LIMITS.contextElementChars)),
+            };
+        case 'image':
+            return {
+                ...clampAlt(block),
+                ...(block.title && {
+                    title: clampText(block.title, blocks_1.SLACK_LIMITS.imageTitleChars),
+                }),
+            };
+        case 'video':
+            return {
+                ...block,
+                title: clampText(block.title, blocks_1.SLACK_LIMITS.videoTitleChars),
+                ...(block.description && {
+                    description: clampText(block.description, blocks_1.SLACK_LIMITS.videoDescriptionChars),
+                }),
+                ...(block.author_name !== undefined && {
+                    author_name: (0, format_1.clampSlackText)(block.author_name, blocks_1.SLACK_LIMITS.videoAuthorNameChars),
+                }),
+            };
+        case 'actions':
+            return { ...block, elements: block.elements.map(clampControl) };
+        default:
+            return block;
+    }
+};
+const collectSlackFileRefs = (blocks) => {
+    const refs = new Set();
+    for (const block of blocks) {
+        if (block.type === 'image' && block.slack_file?.ref !== undefined) {
+            refs.add(block.slack_file.ref);
+        }
+    }
+    return refs;
+};
+const headerBlock = (title, level) => ({
+    type: 'header',
+    text: { type: 'plain_text', text: (0, format_1.formatHeaderText)(title), emoji: true },
+    ...(level !== undefined ? { level } : {}),
+});
+const contextBlock = (lines) => ({
+    type: 'context',
+    elements: lines
+        .filter((line) => line !== undefined && line.length > 0)
+        .map((text) => ({
+        type: 'mrkdwn',
+        text: (0, format_1.clampMrkdwn)(text, blocks_1.SLACK_LIMITS.contextElementChars),
+    })),
+});
+const SLACK_SPACER_TEXT = ' ';
+const slackSpacerBlock = () => ({
+    type: 'section',
+    text: { type: 'mrkdwn', text: SLACK_SPACER_TEXT },
+});
+const isSpacer = (block) => block.type === 'section' &&
+    block.text?.type === 'mrkdwn' &&
+    block.text.text === SLACK_SPACER_TEXT &&
+    block.fields === undefined &&
+    block.accessory === undefined;
+const isFieldsOnly = (block) => block.type === 'section' &&
+    (block.fields?.length ?? 0) > 0 &&
+    block.text === undefined &&
+    block.accessory === undefined;
+const isContent = (block) => block.type !== 'header' &&
+    block.type !== 'divider' &&
+    block.type !== 'actions' &&
+    block.type !== 'context' &&
+    !isSpacer(block);
+// Consecutive 1-field sections pack into Slack's two-column `fields` grid.
+// A section that already has 2+ fields is a finished batch (e.g. a
+// description list) and is left alone.
+const coalesceFieldSections = (blocks) => {
+    const out = [];
+    let index = 0;
+    while (index < blocks.length) {
+        const block = blocks[index];
+        if (isFieldsOnly(block) && block.fields?.length === 1) {
+            const fields = [...block.fields];
+            index += 1;
+            while (index < blocks.length) {
+                const next = blocks[index];
+                if (!isFieldsOnly(next) ||
+                    next.fields.length !== 1 ||
+                    fields.length >= blocks_1.SLACK_LIMITS.fieldsPerSection) {
+                    break;
+                }
+                fields.push(...next.fields);
+                index += 1;
+            }
+            out.push({ type: 'section', fields });
+            continue;
+        }
+        out.push(block);
+        index += 1;
+    }
+    return out;
+};
+// Divider before every section heading (and trailing actions) after the
+// composition title; spacer after each content run except a table already
+// about to be followed by a divider. Consecutive field-only sections are
+// not spaced — they read as one grid.
+const applySectionRhythm = (blocks) => {
+    if (blocks.length === 0) {
+        return [];
+    }
+    const out = [];
+    for (let index = 0; index < blocks.length; index += 1) {
+        const block = blocks[index];
+        const prev = out[out.length - 1];
+        const needsDividerBefore = (block.type === 'header' && out.length > 0) || block.type === 'actions';
+        if (needsDividerBefore && prev && prev.type !== 'divider') {
+            if (isContent(prev) && prev.type !== 'table') {
+                out.push(slackSpacerBlock());
+            }
+            out.push({ type: 'divider' });
+        }
+        out.push(block);
+        if (isContent(block) && index + 1 < blocks.length) {
+            const next = blocks[index + 1];
+            if (isContent(next) && !(isFieldsOnly(block) && isFieldsOnly(next))) {
+                out.push(slackSpacerBlock());
+            }
+        }
+    }
+    return out;
+};
+const truncateWithNotice = (blocks) => {
+    const kept = blocks.slice(0, blocks_1.SLACK_LIMITS.blocksPerMessage - 1);
+    const dropped = blocks.length - kept.length;
+    kept.push(contextBlock([
+        (0, format_1.italic)(`+${dropped} more blocks elided to fit Slack's limit.`),
+    ]));
+    return kept;
+};
+const richTextInlineText = (inline) => inline.type === 'link' ? (inline.text ?? inline.url) : inline.text;
+const richTextElementText = (element) => element.type === 'rich_text_list'
+    ? element.elements.map(richTextElementText).join('')
+    : element.elements.map(richTextInlineText).join('');
+const tableCellText = (cell) => cell.type === 'raw_text'
+    ? cell.text
+    : cell.elements.map(richTextElementText).join('');
+const tableCharCount = (block) => block.rows.reduce((total, row) => total + row.reduce((sum, cell) => sum + tableCellText(cell).length, 0), 0);
+const textRun = (text) => ({ type: 'text', text });
+const richSection = (elements) => ({ type: 'rich_text_section', elements });
+const rowBreak = () => richSection([textRun('\n')]);
+const cellElements = (cell) => {
+    if (cell?.type === 'rich_text') {
+        return cell.elements.filter(({ elements }) => elements.length > 0);
+    }
+    return cell?.text ? [richSection([textRun(cell.text)])] : [];
+};
+const boldInline = (inline) => ({
+    ...inline,
+    style: { ...inline.style, bold: true },
+});
+const boldElement = (element) => element.type === 'rich_text_list'
+    ? {
+        ...element,
+        elements: element.elements.map((item) => ({
+            ...item,
+            elements: item.elements.map(boldInline),
+        })),
+    }
+    : { ...element, elements: element.elements.map(boldInline) };
+const isBlank = (cell) => cell === undefined || tableCellText(cell).trim() === '';
+// A one-section heading leads its cell as `heading: `; any other heading keeps
+// its blocks, bold, above the cell. A blank heading leaves the cell alone.
+const columnElements = (heading, cell) => {
+    const body = cellElements(cell);
+    if (isBlank(heading)) {
+        return body;
+    }
+    const head = cellElements(heading);
+    const [only] = head;
+    if (head.length !== 1 || only?.type !== 'rich_text_section') {
+        return [...head.map(boldElement), ...body];
+    }
+    const lead = [...only.elements.map(boldInline), textRun(': ')];
+    const [first, ...rest] = body;
+    return first?.type === 'rich_text_section'
+        ? [richSection([...lead, ...first.elements]), ...rest]
+        : [richSection(lead), ...body];
+};
+const endsLine = (element) => /[\n\r\u2028\u2029]$/u.test(richTextElementText(element));
+// Slack runs adjacent sections together, so a section followed by another ends
+// its line unless its rendered text already does.
+const breakSections = (elements) => elements.map((element, index) => element.type === 'rich_text_section' &&
+    elements[index + 1]?.type === 'rich_text_section' &&
+    !endsLine(element)
+    ? richSection([...element.elements, textRun('\n')])
+    : element);
+// Graphemes, and the code points of any grapheme past `max`.
+const textUnits = (text, max) => Array.from(new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(text), ({ segment }) => (segment.length > max ? Array.from(segment) : [segment])).flat();
+/**
+ * A section, quote, or preformatted element past `sectionTextChars` as adjacent ones of its type, with nothing added between them; a list comes back as is.
+ * A link or tag no longer than that stays whole; anything longer splits at grapheme boundaries into inlines of its own type, a link's label (or URL) across links to the same URL.
+ */
+const splitRichTextElement = (element) => {
+    const max = blocks_1.SLACK_LIMITS.sectionTextChars;
+    if (element.type === 'rich_text_list' ||
+        richTextElementText(element).length <= max) {
+        return [element];
+    }
+    const chunks = [];
+    let chunk = [];
+    let room = max;
+    const flush = () => {
+        if (chunk.length > 0) {
+            chunks.push(chunk);
+        }
+        chunk = [];
+        room = max;
+    };
+    for (const inline of element.elements) {
+        const whole = richTextInlineText(inline);
+        if (inline.type !== 'text' && whole.length <= max) {
+            if (whole.length > room) {
+                flush();
+            }
+            chunk.push(inline);
+            room -= whole.length;
+            continue;
+        }
+        let text = '';
+        for (const unit of textUnits(whole, max)) {
+            if (text.length + unit.length > room) {
+                if (text) {
+                    chunk.push({ ...inline, text });
+                }
+                flush();
+                text = '';
+            }
+            text += unit;
+        }
+        if (text) {
+            chunk.push({ ...inline, text });
+            room -= text.length;
+        }
+    }
+    flush();
+    return chunks.map((elements) => ({ ...element, elements }));
+};
+// A table Slack would reject is replaced by one `rich_text` block. Each row's
+// columns run `heading: cell` to the wider of the header and the row, and a
+// blank section parts the rows. A cell keeps its inlines, styles, and blocks; a
+// table whose rows past the header have no cells prints its headings, and one
+// with nothing to print is dropped.
+const degradeTable = ({ rows: [header = [], ...body], }) => {
+    const rows = body.filter((row) => row.length > 0);
+    const pieces = rows.length === 0
+        ? [
+            header
+                .filter((heading) => !isBlank(heading))
+                .flatMap((heading) => cellElements(heading).map(boldElement)),
+        ]
+        : rows.map((row) => Array.from({ length: Math.max(header.length, row.length) }, (_, column) => columnElements(header[column], row[column])).flat());
+    const elements = pieces
+        .filter((piece) => piece.length > 0)
+        .flatMap((piece, index) => (index > 0 ? [rowBreak(), ...piece] : piece));
+    return elements.length === 0
+        ? []
+        : [
+            {
+                type: 'rich_text',
+                elements: breakSections(elements).flatMap(splitRichTextElement),
+            },
+        ];
+};
+const fitsTableShape = ({ rows }) => rows.length > 0 &&
+    rows.length <= blocks_1.SLACK_LIMITS.tableRows &&
+    rows.every((row) => row.length > 0 && row.length <= blocks_1.SLACK_LIMITS.tableColumns);
+// Slack counts table cell characters across the whole message, not per block,
+// so a composition whose tables individually fit can still be rejected. In
+// document order, a table is kept if its shape fits and its cells fit what the
+// kept ones left.
+const enforceTableLimits = (blocks) => {
+    let spent = 0;
+    return blocks.flatMap((block) => {
+        if (block.type !== 'table') {
+            return [block];
+        }
+        const cost = tableCharCount(block);
+        if (fitsTableShape(block) &&
+            spent + cost <= blocks_1.SLACK_LIMITS.tableCellCharsPerMessage) {
+            spent += cost;
+            return [block];
+        }
+        return degradeTable(block);
+    });
+};
+const enforceBlockBudget = (blocks) => {
+    if (blocks.length <= blocks_1.SLACK_LIMITS.blocksPerMessage) {
+        return blocks;
+    }
+    const trimmed = [...blocks];
+    for (let index = trimmed.length - 1; index >= 0 && trimmed.length > blocks_1.SLACK_LIMITS.blocksPerMessage; index -= 1) {
+        if (isSpacer(trimmed[index])) {
+            trimmed.splice(index, 1);
+        }
+    }
+    if (trimmed.length <= blocks_1.SLACK_LIMITS.blocksPerMessage) {
+        return trimmed;
+    }
+    return truncateWithNotice(trimmed);
+};
+//# sourceMappingURL=envelope.js.map