@droppii-org/chat-mobile 0.2.81 → 0.2.83

package/src/utils/mentions/mentionTokenize.ts

@@ -0,0 +1,53 @@
+import type { Mention } from '../../types/mention';
+
+export type Segment =
+  | { type: 'text'; text: string; start: number; end: number }
+  | { type: 'mention'; mention: Mention };
+
+/**
+ * Converts edit-time state (flat string + Mention[] ranges) into an
+ * ordered list of plain-text runs and mention tokens — the shape both the
+ * composer's highlight renderer (Phase A3) and the sent-message bubble
+ * renderer (Phase B3) need to produce their styled `<Text>` children.
+ * Shared by both so the segment-splitting logic exists exactly once.
+ *
+ * O(m log m) sort + O(n) slicing (m = mention count, n = text length) —
+ * trivial at the sizes this feature targets (≤50 mentions, ≤2000 chars).
+ *
+ * Precondition: `mentions` is non-overlapping, guaranteed by Phase A1's own
+ * pipeline (insertMention/reconcileMentions never produce overlaps). The
+ * `m.start < cursor` skip below is a defensive backstop for
+ * externally-sourced data (a message loaded for editing, or an `ex` blob
+ * serialized by an older app version) — not a correctness dependency for
+ * the live composer.
+ */
+export function tokenize(text: string, mentions: Mention[]): Segment[] {
+  const sorted = [...mentions].sort((a, b) => a.start - b.start);
+  const segments: Segment[] = [];
+  let cursor = 0;
+
+  for (const m of sorted) {
+    if (m.start < cursor) continue; // overlapping/malformed entry — skip rather than produce a negative-length slice
+    if (m.start > cursor) {
+      segments.push({
+        type: 'text',
+        text: text.slice(cursor, m.start),
+        start: cursor,
+        end: m.start,
+      });
+    }
+    segments.push({ type: 'mention', mention: m });
+    cursor = m.end;
+  }
+
+  if (cursor < text.length) {
+    segments.push({
+      type: 'text',
+      text: text.slice(cursor),
+      start: cursor,
+      end: text.length,
+    });
+  }
+
+  return segments;
+}

package/src/utils/messageUtils.ts

@@ -272,7 +272,12 @@ export const getMessagePreview = (message?: MessageItem): string => {
       return urlText ? urlText : '';
 
     case MessageType.AtTextMessage:
-      return extractTextContent(message);
+      // Bug: was calling extractTextContent(message) directly, which only
+      // checks message.textElem?.content (wrong elem for this type — always
+      // undefined here) before falling back to JSON.parse(message.content).
+      // atTextElem.text is the actual plain text for this message type —
+      // read it first, matching the QuoteMessage case right below.
+      return message?.atTextElem?.text || extractTextContent(message) || '';
 
     case MessageType.QuoteMessage:
       return message?.quoteElem?.text || extractTextContent(message) || '';

package/src/utils/url.ts

@@ -33,6 +33,36 @@ export function extractUrls(text: string): string[] {
   return text.match(URL_REGEX) ?? [];
 }
 
+export interface TextUrlPart {
+  text: string;
+  isUrl: boolean;
+}
+
+/**
+ * Splits `text` into an ordered run of plain/URL parts — pure data, no
+ * JSX, so both LinkMessage (a whole message that's just text+URLs) and
+ * TextMessage (a mention message whose plain-text *segments* may also
+ * contain a URL) can render URL styling from the same source instead of
+ * two divergent implementations.
+ */
+export function splitTextByUrls(text: string, urls: string[]): TextUrlPart[] {
+  if (!urls.length) return [{ text, isUrl: false }];
+
+  const parts: TextUrlPart[] = [];
+  let remaining = text;
+
+  for (const url of urls) {
+    const idx = remaining.indexOf(url);
+    if (idx === -1) continue;
+    if (idx > 0) parts.push({ text: remaining.slice(0, idx), isUrl: false });
+    parts.push({ text: url, isUrl: true });
+    remaining = remaining.slice(idx + url.length);
+  }
+
+  if (remaining) parts.push({ text: remaining, isUrl: false });
+  return parts;
+}
+
 export function normalizeUrl(url: string) {
   if (!/^https?:\/\//i.test(url)) {
     return `https://${url}`;