openbird 1.0.0

package/src/core/builders/richtext.js

@@ -0,0 +1,592 @@
+/**
+ * RichText Builder for Feishu messages
+ * Converts Markdown-like syntax to Feishu RichText protobuf structure
+ */
+
+import { create, toBinary } from '@bufbuild/protobuf';
+import { TextPropertySchema } from '../proto/proto_pb.js';
+import { pushVarintLength } from '../utils/varint.js';
+
+// RichText Element Tags
+const Tags = {
+  TEXT: 1,
+  P: 3,
+  A: 6,
+  DOCS: 22,
+  UL: 26,
+  OL: 27,
+  LI: 28,
+  QUOTE: 29,
+  CODE_BLOCK: 31,
+};
+
+// Style keys for text formatting
+const Styles = {
+  ITALIC: { fontStyle: 'italic' },
+  BOLD: { fontWeight: 'bold' },
+  STRIKETHROUGH: { '-lark-textDecoration': 'lineThrough' },
+  UNDERLINE: { '-lark-textDecoration': 'underline' },
+};
+
+// Simple ID generator
+let idCounter = 0;
+function nextId() {
+  return String(++idCounter);
+}
+function resetIdCounter() {
+  idCounter = 0;
+}
+
+/**
+ * Manually build RichTextElement bytes
+ * Format: tag(varint) + property(bytes, can be empty 1a00) + childIds(repeated string)
+ */
+function buildElementBytes(tag, property = null, childIds = []) {
+  const parts = [];
+
+  // Field 1: tag (varint)
+  parts.push(0x08); // field 1, wire type 0
+  parts.push(tag);
+
+  // Field 3: property (bytes) - MUST include even if empty
+  parts.push(0x1a); // field 3, wire type 2
+  if (property && property.length > 0) {
+    pushVarintLength(parts, property.length);
+    parts.push(...property);
+  } else {
+    parts.push(0x00); // empty bytes
+  }
+
+  // Field 4: childIds (repeated string)
+  for (const childId of childIds) {
+    parts.push(0x22); // field 4, wire type 2
+    const idBytes = new TextEncoder().encode(childId);
+    pushVarintLength(parts, idBytes.length);
+    parts.push(...idBytes);
+  }
+
+  return new Uint8Array(parts);
+}
+
+/**
+ * Build dictionary entry bytes
+ */
+function buildDictEntry(key, elementBytes) {
+  const keyBytes = new TextEncoder().encode(key);
+  const entryParts = [];
+
+  // Field 1: key (string)
+  entryParts.push(0x0a);
+  pushVarintLength(entryParts, keyBytes.length);
+  entryParts.push(...keyBytes);
+
+  // Field 2: value (element bytes)
+  entryParts.push(0x12);
+  pushVarintLength(entryParts, elementBytes.length);
+  entryParts.push(...elementBytes);
+
+  return new Uint8Array(entryParts);
+}
+
+/**
+ * Build complete dictionary bytes from entries
+ */
+function buildDictionaryBytes(entries) {
+  const parts = [];
+  for (const [key, elementBytes] of Object.entries(entries)) {
+    const entryBytes = buildDictEntry(key, elementBytes);
+    // Map entry wrapper
+    parts.push(0x0a); // field 1 (map), wire type 2
+    pushVarintLength(parts, entryBytes.length);
+    parts.push(...entryBytes);
+  }
+  return new Uint8Array(parts);
+}
+
+/**
+ * Build TEXT element with property
+ */
+function buildTextElement(text, styles = {}) {
+  const textProperty = create(TextPropertySchema, { content: text });
+  const propertyBytes = toBinary(TextPropertySchema, textProperty);
+
+  // If has styles, need to add style field
+  if (Object.keys(styles).length > 0) {
+    return buildElementBytesWithStyle(Tags.TEXT, propertyBytes, [], styles);
+  }
+
+  return buildElementBytes(Tags.TEXT, propertyBytes, []);
+}
+
+/**
+ * Build element with style
+ */
+function buildElementBytesWithStyle(tag, property, childIds, styles) {
+  const parts = [];
+
+  // Field 1: tag
+  parts.push(0x08);
+  parts.push(tag);
+
+  // Field 2: style (map<string, string>)
+  for (const [key, value] of Object.entries(styles)) {
+    const keyBytes = new TextEncoder().encode(key);
+    const valueBytes = new TextEncoder().encode(value);
+
+    // Style entry
+    const styleEntry = [];
+    styleEntry.push(0x0a); // key field
+    pushVarintLength(styleEntry, keyBytes.length);
+    styleEntry.push(...keyBytes);
+    styleEntry.push(0x12); // value field
+    pushVarintLength(styleEntry, valueBytes.length);
+    styleEntry.push(...valueBytes);
+
+    parts.push(0x12); // field 2, wire type 2
+    pushVarintLength(parts, styleEntry.length);
+    parts.push(...styleEntry);
+  }
+
+  // Field 3: property
+  parts.push(0x1a);
+  if (property && property.length > 0) {
+    pushVarintLength(parts, property.length);
+    parts.push(...property);
+  } else {
+    parts.push(0x00);
+  }
+
+  // Field 4: childIds
+  for (const childId of childIds) {
+    parts.push(0x22);
+    const idBytes = new TextEncoder().encode(childId);
+    pushVarintLength(parts, idBytes.length);
+    parts.push(...idBytes);
+  }
+
+  return new Uint8Array(parts);
+}
+
+/**
+ * Encode link property
+ */
+function encodeLinkProperty(url, text) {
+  const urlBytes = new TextEncoder().encode(url);
+  const textBytes = new TextEncoder().encode(text);
+  const buffer = [];
+  buffer.push(0x0a);
+  pushVarintLength(buffer, urlBytes.length);
+  buffer.push(...urlBytes);
+  buffer.push(0x12);
+  pushVarintLength(buffer, textBytes.length);
+  buffer.push(...textBytes);
+  buffer.push(0x48, 0x01); // field 9 = 1
+  buffer.push(0x50, 0x03); // field 10 = 3
+  return new Uint8Array(buffer);
+}
+
+/**
+ * Encode UL property
+ */
+function encodeULProperty() {
+  return new Uint8Array([0x08, 0x00]);
+}
+
+/**
+ * Encode OL property with start index
+ * @param {number} startIndex - The starting number for the ordered list (default: 1)
+ */
+function encodeOLProperty(startIndex = 1) {
+  // Ensure startIndex is at least 1
+  const index = Math.max(1, startIndex);
+
+  // For numbers <= 127, single byte encoding works
+  if (index <= 127) {
+    return new Uint8Array([0x08, 0x00, 0x10, index]);
+  }
+
+  // For larger numbers, use varint encoding for field 2
+  const bytes = [0x08, 0x00, 0x10];
+  let value = index;
+  while (value > 127) {
+    bytes.push((value & 0x7f) | 0x80);
+    value >>= 7;
+  }
+  bytes.push(value);
+  return new Uint8Array(bytes);
+}
+
+/**
+ * Unwrap inline Markdown style markers when they wrap the whole text
+ * Supports nested wrappers like **__text__**
+ */
+function unwrapInlineStyles(text) {
+  let content = text;
+  let style = {};
+  let changed = true;
+
+  while (changed && content) {
+    changed = false;
+    let match;
+
+    match = content.match(/^\*\*(.+)\*\*$/);
+    if (match) {
+      style = { ...style, ...Styles.BOLD };
+      content = match[1];
+      changed = true;
+      continue;
+    }
+
+    match = content.match(/^__(.+)__$/);
+    if (match) {
+      style = { ...style, ...Styles.UNDERLINE };
+      content = match[1];
+      changed = true;
+      continue;
+    }
+
+    match = content.match(/^~~(.+)~~$/);
+    if (match) {
+      style = { ...style, ...Styles.STRIKETHROUGH };
+      content = match[1];
+      changed = true;
+      continue;
+    }
+
+    match = content.match(/^\*(.+)\*$/) || content.match(/^_(.+)_$/);
+    if (match) {
+      style = { ...style, ...Styles.ITALIC };
+      content = match[1];
+      changed = true;
+    }
+  }
+
+  return { content, style };
+}
+
+/**
+ * Parse inline formatting
+ */
+function parseInlineFormatting(text) {
+  const elements = [];
+  const elementBytes = {};
+  let innerText = '';
+
+  const combinedRegex = /(\*\*\[([^\]]+)\]\(([^)]+)\)\*\*)|(\[\*\*([^\]]+)\*\*\]\(([^)]+)\))|(\*\*(.+?)\*\*)|(~~(.+?)~~)|(__(.+?)__)|(\*(.+?)\*)|(_([^_]+)_)|(\[([^\]]+)\]\(([^)]+)\))/g;
+
+  let match;
+  const matches = [];
+
+  while ((match = combinedRegex.exec(text)) !== null) {
+    let type = 'unknown';
+    let content = '';
+    let url = null;
+    let style = {};
+
+    if (match[1]) {
+      type = 'link';
+      content = match[2];
+      url = match[3];
+      style = { ...Styles.BOLD };
+    } else if (match[4]) {
+      type = 'link';
+      content = match[5];
+      url = match[6];
+      style = { ...Styles.BOLD };
+    } else if (match[7]) {
+      type = 'bold';
+      content = match[8];
+    } else if (match[9]) {
+      type = 'strikethrough';
+      content = match[10];
+    } else if (match[11]) {
+      type = 'underline';
+      content = match[12];
+    } else if (match[13]) {
+      type = 'italic';
+      content = match[14];
+    } else if (match[15]) {
+      type = 'italic';
+      content = match[16];
+    } else if (match[17]) {
+      type = 'link';
+      content = match[18];
+      url = match[19];
+    }
+
+    matches.push({
+      index: match.index,
+      length: match[0].length,
+      type,
+      content,
+      url,
+      style,
+    });
+  }
+
+  matches.sort((a, b) => a.index - b.index);
+
+  let currentIndex = 0;
+
+  for (const m of matches) {
+    if (m.index > currentIndex) {
+      const plainText = text.substring(currentIndex, m.index);
+      if (plainText) {
+        const id = nextId();
+        elements.push(id);
+        elementBytes[id] = buildTextElement(plainText);
+        innerText += plainText;
+      }
+    }
+
+    const id = nextId();
+    elements.push(id);
+
+    if (m.type === 'link') {
+      const normalized = unwrapInlineStyles(m.content);
+      const linkContent = normalized.content;
+      const linkStyle = { ...m.style, ...normalized.style };
+      const linkProp = encodeLinkProperty(m.url, linkContent);
+
+      if (Object.keys(linkStyle).length > 0) {
+        elementBytes[id] = buildElementBytesWithStyle(Tags.A, linkProp, [], linkStyle);
+      } else {
+        elementBytes[id] = buildElementBytes(Tags.A, linkProp, []);
+      }
+
+      innerText += linkContent;
+    } else {
+      let style = {};
+      switch (m.type) {
+        case 'bold': style = Styles.BOLD; break;
+        case 'italic': style = Styles.ITALIC; break;
+        case 'strikethrough': style = Styles.STRIKETHROUGH; break;
+        case 'underline': style = Styles.UNDERLINE; break;
+      }
+      elementBytes[id] = buildTextElement(m.content, style);
+      innerText += m.content;
+    }
+
+    currentIndex = m.index + m.length;
+  }
+
+  if (currentIndex < text.length) {
+    const plainText = text.substring(currentIndex);
+    if (plainText) {
+      const id = nextId();
+      elements.push(id);
+      elementBytes[id] = buildTextElement(plainText);
+      innerText += plainText;
+    }
+  }
+
+  if (elements.length === 0) {
+    const id = nextId();
+    elements.push(id);
+    elementBytes[id] = buildTextElement(text);
+    innerText = text;
+  }
+
+  return { elementIds: elements, elementBytes, innerText };
+}
+
+/**
+ * Parse a single line and return its block structure
+ * IDs are assigned depth-first (outside-in per block)
+ * @param {string} line - Single line of text
+ * @returns {Object} { blockChildId, elementBytes, innerText }
+ */
+function parseSingleLine(line) {
+  const elementBytes = {};
+  let innerText = '';
+
+  // Check for quote
+  if (line.startsWith('> ')) {
+    const content = line.substring(2);
+
+    // Parse inline formatting within quote content
+    const inline = parseInlineFormatting(content);
+    Object.assign(elementBytes, inline.elementBytes);
+    innerText = inline.innerText;
+
+    // Structure: QUOTE → P → [inline elements]
+    const quoteId = nextId();
+    const pId = nextId();
+
+    elementBytes[pId] = buildElementBytes(Tags.P, null, inline.elementIds);
+    elementBytes[quoteId] = buildElementBytes(Tags.QUOTE, null, [pId]);
+
+    return { blockChildId: quoteId, elementBytes, innerText };
+  }
+
+  // Check for unordered list
+  if (/^[-*] /.test(line)) {
+    const content = line.substring(2);
+
+    // Parse inline formatting within list item
+    const inline = parseInlineFormatting(content);
+    Object.assign(elementBytes, inline.elementBytes);
+    innerText = inline.innerText;
+
+    // Structure: UL → LI → [inline elements]
+    const ulId = nextId();
+    const liId = nextId();
+
+    elementBytes[liId] = buildElementBytes(Tags.LI, null, inline.elementIds);
+    elementBytes[ulId] = buildElementBytes(Tags.UL, encodeULProperty(), [liId]);
+
+    return { blockChildId: ulId, elementBytes, innerText };
+  }
+
+  // Check for ordered list
+  const olMatch = line.match(/^(\d+)\. /);
+  if (olMatch) {
+    const startIndex = parseInt(olMatch[1], 10);
+    const content = line.replace(/^\d+\. /, '');
+
+    // Parse inline formatting within list item
+    const inline = parseInlineFormatting(content);
+    Object.assign(elementBytes, inline.elementBytes);
+    innerText = inline.innerText;
+
+    // Structure: OL → LI → [inline elements]
+    const olId = nextId();
+    const liId = nextId();
+
+    elementBytes[liId] = buildElementBytes(Tags.LI, null, inline.elementIds);
+    elementBytes[olId] = buildElementBytes(Tags.OL, encodeOLProperty(startIndex), [liId]);
+
+    return { blockChildId: olId, elementBytes, innerText };
+  }
+
+  // Plain text line - may contain inline formatting (bold, italic, etc.)
+  // Parse inline formatting and wrap in P element
+  const inline = parseInlineFormatting(line);
+  Object.assign(elementBytes, inline.elementBytes);
+  innerText = inline.innerText;
+
+  // Wrap inline elements in a P element
+  const pId = nextId();
+  elementBytes[pId] = buildElementBytes(Tags.P, null, inline.elementIds);
+
+  return { blockChildId: pId, elementBytes, innerText };
+}
+
+/**
+ * Build RichText structure from Markdown text
+ * Supports multi-line mixed format (plain text + quotes + lists)
+ */
+export function buildRichText(markdown) {
+  resetIdCounter();
+  const elementBytes = {};
+  let innerText = '';
+
+  // Check for code block (special case - takes entire content)
+  const codeBlockMatch = markdown.match(/^```(\w*)\n?([\s\S]*?)```$/);
+  if (codeBlockMatch) {
+    const language = codeBlockMatch[1] || 'java';
+    const code = codeBlockMatch[2].trim();
+    innerText = `[代码块]`;
+
+    // Build from outside to inside, IDs from 1 to N
+    // Structure: DOCS(1) → P(2) → CODE_BLOCK(3)
+    const docsId = nextId(); // "1"
+    const pId = nextId();    // "2"
+    const codeId = nextId(); // "3"
+
+    // CODE_BLOCK with language property
+    const langBytes = new TextEncoder().encode(language);
+    const codeBlockProp = new Uint8Array([
+      0x08, 0x1f, // field 1 = 31
+      0x12, langBytes.length + 2, 0x12, langBytes.length, ...langBytes
+    ]);
+    elementBytes[codeId] = buildElementBytes(Tags.CODE_BLOCK, codeBlockProp, []);
+
+    // P → CODE_BLOCK
+    elementBytes[pId] = buildElementBytes(Tags.P, null, [codeId]);
+
+    // DOCS → P
+    elementBytes[docsId] = buildElementBytes(Tags.DOCS, null, [pId]);
+
+    return {
+      elementIds: [docsId],
+      innerText,
+      dictionaryBytes: buildDictionaryBytes(elementBytes),
+      isBlockLevel: true,
+    };
+  }
+
+  // Split into lines and filter empty lines
+  const lines = markdown.split('\n').filter(line => line.trim());
+
+  // Check if this is multi-line or has block-level elements
+  const hasMultipleLines = lines.length > 1;
+  const hasBlockElement = lines.some(line =>
+    line.startsWith('> ') ||
+    /^[-*] /.test(line) ||
+    /^\d+\. /.test(line)
+  );
+
+  // If single line without block elements, use simple inline formatting
+  if (!hasMultipleLines && !hasBlockElement) {
+    const inline = parseInlineFormatting(markdown);
+    Object.assign(elementBytes, inline.elementBytes);
+    innerText = inline.innerText;
+
+    return {
+      elementIds: inline.elementIds,
+      innerText,
+      dictionaryBytes: buildDictionaryBytes(elementBytes),
+      isBlockLevel: false,
+    };
+  }
+
+  // Multi-line or has block elements: build DOCS structure
+  // IDs assigned depth-first: DOCS first, then each block fully (outside-in)
+  const docsId = nextId(); // "1"
+  const blockChildIds = [];
+  const innerTexts = [];
+
+  for (const line of lines) {
+    const parsed = parseSingleLine(line);
+    blockChildIds.push(parsed.blockChildId);
+    Object.assign(elementBytes, parsed.elementBytes);
+    innerTexts.push(parsed.innerText);
+  }
+
+  // Build DOCS with all block children
+  elementBytes[docsId] = buildElementBytes(Tags.DOCS, null, blockChildIds);
+  innerText = innerTexts.join('');
+
+  return {
+    elementIds: [docsId],
+    innerText,
+    dictionaryBytes: buildDictionaryBytes(elementBytes),
+    isBlockLevel: true,
+  };
+}
+
+/**
+ * Check if text contains any Markdown formatting
+ */
+export function hasMarkdownFormatting(text) {
+  // Multi-line text is always treated as rich text
+  if (text.includes('\n')) {
+    return true;
+  }
+  const patterns = [
+    /\*\*.+?\*\*/,
+    /\*.+?\*/,
+    /_.+?_/,
+    /~~.+?~~/,
+    /__.+?__/,
+    /\[.+?\]\(.+?\)/,
+    /^> /m,
+    /^[-*] /m,
+    /^\d+\. /m,
+    /^```/m,
+  ];
+  return patterns.some(p => p.test(text));
+}
+
+export { Tags, Styles };