@ihazz/bitrix24 1.1.4 → 1.1.6

package/src/message-utils.ts

@@ -3,6 +3,7 @@ import type { KeyboardButton, B24Keyboard } from './types.js';
 // ─── Placeholder helpers ──────────────────────────────────────────────────────
 
 const PH_ESC = '\x00ESC';    // escape sequences
+const PH_BBCODE = '\x00BB';  // existing BBCode blocks
 const PH_FCODE = '\x00FC';   // fenced code blocks
 const PH_ICODE = '\x00IC';   // inline code
 const PH_HR = '\x00HR';      // horizontal rules
@@ -25,14 +26,21 @@ export function markdownToBbCode(md: string): string {
 
   // ── Phase 1: Protect literals ─────────────────────────────────────────────
 
-  // 1a. Escape sequences: \* \# \_ etc. → placeholders
+  // 1a. Existing [CODE]...[/CODE] blocks should pass through untouched.
+  const bbCodeCodeBlocks: string[] = [];
+  text = text.replace(/\[code(?:=[^\]]+)?\][\s\S]*?\[\/code\]/gi, (block: string) => {
+    bbCodeCodeBlocks.push(block);
+    return `${PH_BBCODE}${bbCodeCodeBlocks.length - 1}\x00`;
+  });
+
+  // 1b. Escape sequences: \* \# \_ etc. → placeholders
   const escapes: string[] = [];
   text = text.replace(/\\([\\`*_{}[\]()#+\-.!~|>])/g, (_match, ch: string) => {
     escapes.push(ch);
     return `${PH_ESC}${escapes.length - 1}\x00`;
   });
 
-  // 1b. Fenced code blocks (backticks and tildes)
+  // 1c. Fenced code blocks (backticks and tildes)
   const fencedBlocks: string[] = [];
   text = text.replace(/^(`{3,})[^\n`]*\n([\s\S]*?)^\1[ \t]*$/gm, (_match, _fence, code: string) => {
     fencedBlocks.push(code.replace(/\n$/, ''));
@@ -43,7 +51,7 @@ export function markdownToBbCode(md: string): string {
     return `${PH_FCODE}${fencedBlocks.length - 1}\x00`;
   });
 
-  // 1c. Inline code (backticks) — single and double backtick
+  // 1d. Inline code (backticks) — single and double backtick
   const inlineCodes: string[] = [];
   text = text.replace(/``([^`]+)``/g, (_match, code: string) => {
     inlineCodes.push(code);
@@ -182,10 +190,16 @@ export function markdownToBbCode(md: string): string {
   // 4b. Fenced/indented code blocks → [CODE]...[/CODE]
   text = text.replace(new RegExp(`${PH_FCODE.replace(/\x00/g, '\\x00')}(\\d+)\\x00`, 'g'), (_m, idx: string) => {
     const value = fencedBlocks[Number(idx)];
-    return value != null ? `[CODE]${value}[/CODE]` : _m;
+    return value != null ? `[CODE]${preserveCodeBlockIndentation(value)}[/CODE]` : _m;
   });
 
-  // 4c. Escape sequences → literal characters
+  // 4c. Existing [CODE]...[/CODE] blocks → original source, untouched
+  text = text.replace(new RegExp(`${PH_BBCODE.replace(/\x00/g, '\\x00')}(\\d+)\\x00`, 'g'), (_m, idx: string) => {
+    const value = bbCodeCodeBlocks[Number(idx)];
+    return value != null ? restoreBbCodeCodeBlock(value) : _m;
+  });
+
+  // 4d. Escape sequences → literal characters
   text = text.replace(new RegExp(`${PH_ESC.replace(/\x00/g, '\\x00')}(\\d+)\\x00`, 'g'), (_m, idx: string) => {
     const value = escapes[Number(idx)];
     return value != null ? value : _m;
@@ -196,13 +210,137 @@ export function markdownToBbCode(md: string): string {
 
 function isInlineAccentToken(value: string): boolean {
   const trimmed = value.trim();
-  if (!trimmed || /\s/.test(trimmed)) return false;
+  if (!trimmed || /[\r\n\t]/.test(trimmed) || trimmed.length > 64) {
+    return false;
+  }
 
-  if (/^\/[a-z0-9][a-z0-9._:-]*$/i.test(trimmed)) {
+  if (isWrappedInlineAccentToken(trimmed)) {
     return true;
   }
 
-  return /^[A-Z][A-Z0-9+._/-]{1,15}$/.test(trimmed);
+  if (looksLikeInlineCodeSnippet(trimmed)) {
+    return false;
+  }
+
+  return isInlineAccentCandidate(trimmed);
+}
+
+function looksLikeInlineCodeSnippet(value: string): boolean {
+  if (/[`"'{};]/.test(value)) {
+    return true;
+  }
+
+  if (/(===|!==|==|!=|<=|>=|=>|\+\+|--|\|\||&&|\?\?)/.test(value)) {
+    return true;
+  }
+
+  return /\b(?:const|let|var|function|class|return|await|async|import|export|from|yield|switch|case)\b/.test(value);
+}
+
+function isWrappedInlineAccentToken(value: string): boolean {
+  const match = value.match(/^([("'`])(.+)([)"'`])$/);
+  if (!match) {
+    return false;
+  }
+
+  const open = match[1];
+  const inner = match[2].trim();
+  const close = match[3];
+  if (!inner || inner.length > 48) {
+    return false;
+  }
+
+  if ((open === '(' && close !== ')')
+    || (open === '[' && close !== ']')
+    || (open === '{' && close !== '}')
+    || ((open === '"' || open === "'") && close !== open)
+    || (open === '`' && close !== '`')) {
+    return false;
+  }
+
+  if (looksLikeInlineCodeSnippet(inner)) {
+    return false;
+  }
+
+  return isInlineAccentCandidate(inner);
+}
+
+function isLowercaseNaturalLanguageWord(value: string): boolean {
+  if (!value) {
+    return false;
+  }
+
+  return /^[\p{Ll}\p{N}-]+$/u.test(value);
+}
+
+function isInlineAccentWord(value: string): boolean {
+  if (!value) {
+    return false;
+  }
+
+  if (/^\/[a-z0-9][a-z0-9._:-]*$/i.test(value)) {
+    return true;
+  }
+
+  if (/^[vV]?\d+(?:\.\d+)*$/.test(value)) {
+    return true;
+  }
+
+  if (/^(?:[\p{L}\p{N}_-]+)(?:\.[\p{L}\p{N}_*:-]+)+(?:\([^"'`;{}]*\))?$/u.test(value)) {
+    return true;
+  }
+
+  if (/^[\p{L}\p{N}_][\p{L}\p{N}._/:=+*()[\],-]{0,47}$/u.test(value)) {
+    return true;
+  }
+
+  return /^(?=.*\p{Lu}.*\p{Lu})(?=.*\p{Ll})[\p{L}\p{N}+._/-]{2,24}$/u.test(value);
+}
+
+function isInlineAccentCandidate(value: string): boolean {
+  if (/^\/[a-z0-9][a-z0-9._:-]*$/i.test(value)) {
+    return true;
+  }
+
+  const words = value.split(/\s+/).filter(Boolean);
+  if (words.length === 0 || words.length > 6) {
+    return false;
+  }
+
+  if (words.length > 1 && words.every((word) => isLowercaseNaturalLanguageWord(stripInlineAccentPunctuation(word)))) {
+    return false;
+  }
+
+  return words.every((word) => isInlineAccentWord(stripInlineAccentPunctuation(word)));
+}
+
+function stripInlineAccentPunctuation(value: string): string {
+  return value.replace(/^[()[\]{}.,:;!?-]+|[()[\]{}.,:;!?-]+$/g, '');
+}
+
+function preserveCodeBlockIndentation(value: string): string {
+  if (!value.includes('\n')) {
+    return value;
+  }
+
+  return value
+    .split('\n')
+    .map((line) => {
+      const indentMatch = line.match(/^[ \t]+/);
+      if (!indentMatch) {
+        return line;
+      }
+
+      const visibleIndent = indentMatch[0].replace(/\t/g, '    ');
+      return `${'\u00A0'.repeat(visibleIndent.length)}${line.slice(indentMatch[0].length)}`;
+    })
+    .join('\n');
+}
+
+function restoreBbCodeCodeBlock(block: string): string {
+  return block.replace(/^(\[code(?:=[^\]]+)?\])([\s\S]*?)(\[\/code\])$/i, (_match, openTag: string, body: string, closeTag: string) => {
+    return `${openTag}${preserveCodeBlockIndentation(body)}${closeTag}`;
+  });
 }
 
 /**

package/src/send-service.ts

@@ -109,7 +109,7 @@ export class SendService {
         ctx.messageId,
         ctx.commandDialogId ?? ctx.dialogId,
         chunks[0],
-        chunks.length === 1 && options?.keyboard
+        options?.keyboard
           ? { keyboard: options.keyboard }
           : undefined,
       );
@@ -119,18 +119,13 @@ export class SendService {
     }
 
     for (let i = 1; i < chunks.length; i++) {
-      const isLast = i === chunks.length - 1;
-      const msgOptions = isLast && options?.keyboard
-        ? { keyboard: options.keyboard }
-        : undefined;
-
       try {
         lastMessageId = await this.api.sendMessage(
           ctx.webhookUrl,
           ctx.bot,
           ctx.dialogId,
           chunks[i],
-          msgOptions,
+          undefined,
         );
       } catch (error) {
         this.logger.error('Failed to send command follow-up message', { error: serializeError(error) });