@kodelyth/zalouser 2026.5.39 → 2026.5.42

package/src/send.test.ts

@@ -0,0 +1,424 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createZalouserSendReceipt } from "./send-receipt.js";
+import {
+  sendDeliveredZalouser,
+  sendImageZalouser,
+  sendLinkZalouser,
+  sendMessageZalouser,
+  sendReactionZalouser,
+  sendSeenZalouser,
+  sendTypingZalouser,
+} from "./send.js";
+import { parseZalouserTextStyles } from "./text-styles.js";
+import {
+  sendZaloDeliveredEvent,
+  sendZaloLink,
+  sendZaloReaction,
+  sendZaloSeenEvent,
+  sendZaloTextMessage,
+  sendZaloTypingEvent,
+} from "./zalo-js.js";
+import { TextStyle } from "./zca-constants.js";
+
+vi.mock("./zalo-js.js", () => ({
+  sendZaloTextMessage: vi.fn(),
+  sendZaloLink: vi.fn(),
+  sendZaloTypingEvent: vi.fn(),
+  sendZaloReaction: vi.fn(),
+  sendZaloDeliveredEvent: vi.fn(),
+  sendZaloSeenEvent: vi.fn(),
+}));
+
+const mockSendText = vi.mocked(sendZaloTextMessage);
+const mockSendLink = vi.mocked(sendZaloLink);
+const mockSendTyping = vi.mocked(sendZaloTypingEvent);
+const mockSendReaction = vi.mocked(sendZaloReaction);
+const mockSendDelivered = vi.mocked(sendZaloDeliveredEvent);
+const mockSendSeen = vi.mocked(sendZaloSeenEvent);
+
+function sendResult(
+  messageId: string,
+  threadId = "thread",
+): {
+  ok: true;
+  messageId: string;
+  receipt: ReturnType<typeof createZalouserSendReceipt>;
+} {
+  return {
+    ok: true,
+    messageId,
+    receipt: createZalouserSendReceipt({ messageId, threadId, kind: "text" }),
+  };
+}
+
+function sendFailure(error: string, threadId = "thread") {
+  return {
+    ok: false,
+    error,
+    receipt: createZalouserSendReceipt({ threadId, kind: "unknown" }),
+  };
+}
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`${label} was not an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function expectRecordFields(record: Record<string, unknown>, fields: Record<string, unknown>) {
+  for (const [key, value] of Object.entries(fields)) {
+    expect(record[key]).toEqual(value);
+  }
+}
+
+function expectResultFields(result: unknown, fields: Record<string, unknown>) {
+  expectRecordFields(requireRecord(result, "send result"), fields);
+}
+
+function requireSendTextCall(callIndex: number): unknown[] {
+  const call = (mockSendText.mock.calls as unknown[][])[callIndex];
+  if (!call) {
+    throw new Error(`expected send text call ${callIndex + 1}`);
+  }
+  return call;
+}
+
+function requireSendTextOptions(callIndex: number): Record<string, unknown> {
+  return requireRecord(
+    requireSendTextCall(callIndex)[2],
+    `send text call ${callIndex + 1} options`,
+  );
+}
+
+function expectSendTextOptions(callIndex: number, fields: Record<string, unknown>) {
+  expectRecordFields(requireSendTextOptions(callIndex), fields);
+}
+
+describe("zalouser send helpers", () => {
+  beforeEach(() => {
+    mockSendText.mockReset();
+    mockSendLink.mockReset();
+    mockSendTyping.mockReset();
+    mockSendReaction.mockReset();
+    mockSendDelivered.mockReset();
+    mockSendSeen.mockReset();
+  });
+
+  it("keeps plain text literal by default", async () => {
+    mockSendText.mockResolvedValueOnce(sendResult("mid-1", "thread-1"));
+
+    const result = await sendMessageZalouser("thread-1", "**hello**", {
+      profile: "default",
+      isGroup: true,
+    });
+
+    expect(requireSendTextCall(0)[0]).toBe("thread-1");
+    expect(requireSendTextCall(0)[1]).toBe("**hello**");
+    expectSendTextOptions(0, { profile: "default", isGroup: true });
+    expectResultFields(result, { ok: true, messageId: "mid-1" });
+    expect(result.receipt.primaryPlatformMessageId).toBe("mid-1");
+  });
+
+  it("formats markdown text when markdown mode is enabled", async () => {
+    mockSendText.mockResolvedValueOnce(sendResult("mid-1b", "thread-1"));
+
+    await sendMessageZalouser("thread-1", "**hello**", {
+      profile: "default",
+      isGroup: true,
+      textMode: "markdown",
+    });
+
+    expect(requireSendTextCall(0)[0]).toBe("thread-1");
+    expect(requireSendTextCall(0)[1]).toBe("hello");
+    expectSendTextOptions(0, {
+      profile: "default",
+      isGroup: true,
+      textMode: "markdown",
+      textStyles: [{ start: 0, len: 5, st: TextStyle.Bold }],
+    });
+  });
+
+  it("formats image captions in markdown mode", async () => {
+    mockSendText.mockResolvedValueOnce(sendResult("mid-2", "thread-2"));
+
+    await sendImageZalouser("thread-2", "https://example.com/a.png", {
+      profile: "p2",
+      caption: "_cap_",
+      isGroup: false,
+      textMode: "markdown",
+    });
+
+    expect(requireSendTextCall(0)[0]).toBe("thread-2");
+    expect(requireSendTextCall(0)[1]).toBe("cap");
+    expectSendTextOptions(0, {
+      profile: "p2",
+      caption: undefined,
+      isGroup: false,
+      mediaUrl: "https://example.com/a.png",
+      textMode: "markdown",
+      textStyles: [{ start: 0, len: 3, st: TextStyle.Italic }],
+    });
+  });
+
+  it("does not keep the raw markdown caption as a media fallback after formatting", async () => {
+    mockSendText.mockResolvedValueOnce(sendResult("mid-2b", "thread-2"));
+
+    await sendImageZalouser("thread-2", "https://example.com/a.png", {
+      profile: "p2",
+      caption: "```\n```",
+      isGroup: false,
+      textMode: "markdown",
+    });
+
+    expect(requireSendTextCall(0)[0]).toBe("thread-2");
+    expect(requireSendTextCall(0)[1]).toBe("");
+    expectSendTextOptions(0, {
+      profile: "p2",
+      caption: undefined,
+      isGroup: false,
+      mediaUrl: "https://example.com/a.png",
+      textMode: "markdown",
+      textStyles: undefined,
+    });
+  });
+
+  it("rechunks normalized markdown text before sending to avoid transport truncation", async () => {
+    const text = "\t".repeat(500) + "a".repeat(1500);
+    const formatted = parseZalouserTextStyles(text);
+    mockSendText
+      .mockResolvedValueOnce(sendResult("mid-2c-1", "thread-2c"))
+      .mockResolvedValueOnce(sendResult("mid-2c-2", "thread-2c"));
+
+    const result = await sendMessageZalouser("thread-2c", text, {
+      profile: "p2c",
+      isGroup: false,
+      textMode: "markdown",
+    });
+
+    expect(formatted.text.length).toBeGreaterThan(2000);
+    expect(mockSendText).toHaveBeenCalledTimes(2);
+    expect(mockSendText.mock.calls.map((call) => call[1]).join("")).toBe(formatted.text);
+    expect(
+      mockSendText.mock.calls
+        .map((call, index) => ({ index, length: call[1].length }))
+        .filter((call) => call.length > 2000),
+    ).toStrictEqual([]);
+    expectResultFields(result, { ok: true, messageId: "mid-2c-2" });
+  });
+
+  it("preserves text styles when splitting long formatted markdown", async () => {
+    const text = `**${"a".repeat(2501)}**`;
+    mockSendText
+      .mockResolvedValueOnce(sendResult("mid-2d-1", "thread-2d"))
+      .mockResolvedValueOnce(sendResult("mid-2d-2", "thread-2d"));
+
+    const result = await sendMessageZalouser("thread-2d", text, {
+      profile: "p2d",
+      isGroup: false,
+      textMode: "markdown",
+    });
+
+    expect(requireSendTextCall(0)[0]).toBe("thread-2d");
+    expect(requireSendTextCall(0)[1]).toBe("a".repeat(2000));
+    expectSendTextOptions(0, {
+      profile: "p2d",
+      isGroup: false,
+      textMode: "markdown",
+      textStyles: [{ start: 0, len: 2000, st: TextStyle.Bold }],
+    });
+    expect(requireSendTextCall(1)[0]).toBe("thread-2d");
+    expect(requireSendTextCall(1)[1]).toBe("a".repeat(501));
+    expectSendTextOptions(1, {
+      profile: "p2d",
+      isGroup: false,
+      textMode: "markdown",
+      textStyles: [{ start: 0, len: 501, st: TextStyle.Bold }],
+    });
+    expectResultFields(result, { ok: true, messageId: "mid-2d-2" });
+  });
+
+  it("preserves formatted text and styles when newline chunk mode splits after parsing", async () => {
+    const text = `**${"a".repeat(1995)}**\n\nsecond paragraph`;
+    const formatted = parseZalouserTextStyles(text);
+    mockSendText
+      .mockResolvedValueOnce(sendResult("mid-2d-3", "thread-2d-2"))
+      .mockResolvedValueOnce(sendResult("mid-2d-4", "thread-2d-2"));
+
+    const result = await sendMessageZalouser("thread-2d-2", text, {
+      profile: "p2d-2",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkMode: "newline",
+    });
+
+    expect(mockSendText).toHaveBeenCalledTimes(2);
+    expect(mockSendText.mock.calls.map((call) => call[1]).join("")).toBe(formatted.text);
+    expect(requireSendTextCall(0)[0]).toBe("thread-2d-2");
+    expect(requireSendTextCall(0)[1]).toBe(`${"a".repeat(1995)}\n\n`);
+    expectSendTextOptions(0, {
+      profile: "p2d-2",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkMode: "newline",
+      textStyles: [{ start: 0, len: 1995, st: TextStyle.Bold }],
+    });
+    expect(requireSendTextCall(1)[0]).toBe("thread-2d-2");
+    expect(requireSendTextCall(1)[1]).toBe("second paragraph");
+    expectSendTextOptions(1, {
+      profile: "p2d-2",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkMode: "newline",
+      textStyles: undefined,
+    });
+    expectResultFields(result, { ok: true, messageId: "mid-2d-4" });
+  });
+
+  it("respects an explicit text chunk limit when splitting formatted markdown", async () => {
+    const text = `**${"a".repeat(1501)}**`;
+    mockSendText
+      .mockResolvedValueOnce(sendResult("mid-2d-5", "thread-2d-3"))
+      .mockResolvedValueOnce(sendResult("mid-2d-6", "thread-2d-3"));
+
+    const result = await sendMessageZalouser("thread-2d-3", text, {
+      profile: "p2d-3",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkLimit: 1200,
+    } as never);
+
+    expect(mockSendText).toHaveBeenCalledTimes(2);
+    expect(requireSendTextCall(0)[0]).toBe("thread-2d-3");
+    expect(requireSendTextCall(0)[1]).toBe("a".repeat(1200));
+    expectSendTextOptions(0, {
+      profile: "p2d-3",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkLimit: 1200,
+      textStyles: [{ start: 0, len: 1200, st: TextStyle.Bold }],
+    });
+    expect(requireSendTextCall(1)[0]).toBe("thread-2d-3");
+    expect(requireSendTextCall(1)[1]).toBe("a".repeat(301));
+    expectSendTextOptions(1, {
+      profile: "p2d-3",
+      isGroup: false,
+      textMode: "markdown",
+      textChunkLimit: 1200,
+      textStyles: [{ start: 0, len: 301, st: TextStyle.Bold }],
+    });
+    expectResultFields(result, { ok: true, messageId: "mid-2d-6" });
+  });
+
+  it("sends overflow markdown captions as follow-up text after the media message", async () => {
+    const caption = "\t".repeat(500) + "a".repeat(1500);
+    const formatted = parseZalouserTextStyles(caption);
+    mockSendText
+      .mockResolvedValueOnce(sendResult("mid-2e-1", "thread-2e"))
+      .mockResolvedValueOnce(sendResult("mid-2e-2", "thread-2e"));
+
+    const result = await sendImageZalouser("thread-2e", "https://example.com/long.png", {
+      profile: "p2e",
+      caption,
+      isGroup: false,
+      textMode: "markdown",
+    });
+
+    expect(mockSendText).toHaveBeenCalledTimes(2);
+    expect(mockSendText.mock.calls.map((call) => call[1]).join("")).toBe(formatted.text);
+    expect(requireSendTextCall(0)[0]).toBe("thread-2e");
+    expect(typeof requireSendTextCall(0)[1]).toBe("string");
+    expectSendTextOptions(0, {
+      profile: "p2e",
+      caption: undefined,
+      isGroup: false,
+      mediaUrl: "https://example.com/long.png",
+      textMode: "markdown",
+    });
+    expect(requireSendTextCall(1)[0]).toBe("thread-2e");
+    expect(typeof requireSendTextCall(1)[1]).toBe("string");
+    expect(requireSendTextOptions(1).mediaUrl).toBeUndefined();
+    expectResultFields(result, { ok: true, messageId: "mid-2e-2" });
+  });
+
+  it("delegates link helper to JS transport", async () => {
+    mockSendLink.mockResolvedValueOnce(sendFailure("boom", "thread-3"));
+
+    const result = await sendLinkZalouser("thread-3", "https://klaw.kodelyth.com", {
+      profile: "p3",
+      isGroup: true,
+    });
+
+    expect(mockSendLink).toHaveBeenCalledWith("thread-3", "https://klaw.kodelyth.com", {
+      profile: "p3",
+      isGroup: true,
+    });
+    expectResultFields(result, { ok: false, error: "boom" });
+  });
+
+  it("delegates typing helper to JS transport", async () => {
+    await sendTypingZalouser("thread-4", { profile: "p4", isGroup: true });
+
+    expect(mockSendTyping).toHaveBeenCalledWith("thread-4", {
+      profile: "p4",
+      isGroup: true,
+    });
+  });
+
+  it("delegates reaction helper to JS transport", async () => {
+    mockSendReaction.mockResolvedValueOnce({ ok: true });
+
+    const result = await sendReactionZalouser({
+      threadId: "thread-5",
+      profile: "p5",
+      isGroup: true,
+      msgId: "100",
+      cliMsgId: "200",
+      emoji: "👍",
+    });
+
+    expect(mockSendReaction).toHaveBeenCalledWith({
+      profile: "p5",
+      threadId: "thread-5",
+      isGroup: true,
+      msgId: "100",
+      cliMsgId: "200",
+      emoji: "👍",
+      remove: undefined,
+    });
+    expectResultFields(result, { ok: true, error: undefined });
+    expect(result.receipt.platformMessageIds).toStrictEqual([]);
+  });
+
+  it("delegates delivered+seen helpers to JS transport", async () => {
+    mockSendDelivered.mockResolvedValueOnce();
+    mockSendSeen.mockResolvedValueOnce();
+
+    const message = {
+      msgId: "100",
+      cliMsgId: "200",
+      uidFrom: "1",
+      idTo: "2",
+      msgType: "webchat",
+      st: 1,
+      at: 0,
+      cmd: 0,
+      ts: "123",
+    };
+
+    await sendDeliveredZalouser({ profile: "p6", isGroup: true, message, isSeen: false });
+    await sendSeenZalouser({ profile: "p6", isGroup: true, message });
+
+    expect(mockSendDelivered).toHaveBeenCalledWith({
+      profile: "p6",
+      isGroup: true,
+      message,
+      isSeen: false,
+    });
+    expect(mockSendSeen).toHaveBeenCalledWith({
+      profile: "p6",
+      isGroup: true,
+      message,
+    });
+  });
+});

package/src/send.ts

@@ -0,0 +1,280 @@
+import { createZalouserSendReceipt } from "./send-receipt.js";
+import { parseZalouserTextStyles } from "./text-styles.js";
+import type { ZaloEventMessage, ZaloSendOptions, ZaloSendResult } from "./types.js";
+import {
+  sendZaloDeliveredEvent,
+  sendZaloLink,
+  sendZaloReaction,
+  sendZaloSeenEvent,
+  sendZaloTextMessage,
+  sendZaloTypingEvent,
+} from "./zalo-js.js";
+import { TextStyle } from "./zca-constants.js";
+
+type ZalouserSendOptions = ZaloSendOptions;
+type ZalouserSendResult = ZaloSendResult;
+
+const ZALO_TEXT_LIMIT = 2000;
+const DEFAULT_TEXT_CHUNK_MODE = "length";
+
+type StyledTextChunk = {
+  text: string;
+  styles?: ZaloSendOptions["textStyles"];
+};
+
+type TextChunkMode = NonNullable<ZaloSendOptions["textChunkMode"]>;
+
+export async function sendMessageZalouser(
+  threadId: string,
+  text: string,
+  options: ZalouserSendOptions = {},
+): Promise<ZalouserSendResult> {
+  const prepared =
+    options.textMode === "markdown"
+      ? parseZalouserTextStyles(text)
+      : { text, styles: options.textStyles };
+  const textChunkLimit = options.textChunkLimit ?? ZALO_TEXT_LIMIT;
+  const chunks = splitStyledText(
+    prepared.text,
+    (prepared.styles?.length ?? 0) > 0 ? prepared.styles : undefined,
+    textChunkLimit,
+    options.textChunkMode,
+  );
+
+  let lastResult: ZalouserSendResult | null = null;
+  for (const [index, chunk] of chunks.entries()) {
+    const chunkOptions =
+      index === 0
+        ? { ...options, textStyles: chunk.styles }
+        : {
+            ...options,
+            caption: undefined,
+            mediaLocalRoots: undefined,
+            mediaUrl: undefined,
+            textStyles: chunk.styles,
+          };
+    const result = await sendZaloTextMessage(threadId, chunk.text, chunkOptions);
+    if (!result.ok) {
+      return result;
+    }
+    lastResult = result;
+  }
+
+  return (
+    lastResult ?? {
+      ok: false,
+      error: "No message content provided",
+      receipt: createZalouserSendReceipt({ threadId, kind: "text" }),
+    }
+  );
+}
+
+export async function sendImageZalouser(
+  threadId: string,
+  imageUrl: string,
+  options: ZalouserSendOptions = {},
+): Promise<ZalouserSendResult> {
+  return await sendMessageZalouser(threadId, options.caption ?? "", {
+    ...options,
+    caption: undefined,
+    mediaUrl: imageUrl,
+  });
+}
+
+export async function sendLinkZalouser(
+  threadId: string,
+  url: string,
+  options: ZalouserSendOptions = {},
+): Promise<ZalouserSendResult> {
+  return await sendZaloLink(threadId, url, options);
+}
+
+export async function sendTypingZalouser(
+  threadId: string,
+  options: Pick<ZalouserSendOptions, "profile" | "isGroup"> = {},
+): Promise<void> {
+  await sendZaloTypingEvent(threadId, options);
+}
+
+export async function sendReactionZalouser(params: {
+  threadId: string;
+  msgId: string;
+  cliMsgId: string;
+  emoji: string;
+  remove?: boolean;
+  profile?: string;
+  isGroup?: boolean;
+}): Promise<ZalouserSendResult> {
+  const result = await sendZaloReaction({
+    profile: params.profile,
+    threadId: params.threadId,
+    isGroup: params.isGroup,
+    msgId: params.msgId,
+    cliMsgId: params.cliMsgId,
+    emoji: params.emoji,
+    remove: params.remove,
+  });
+  return {
+    ok: result.ok,
+    error: result.error,
+    receipt: createZalouserSendReceipt({ threadId: params.threadId, kind: "unknown" }),
+  };
+}
+
+export async function sendDeliveredZalouser(params: {
+  profile?: string;
+  isGroup?: boolean;
+  message: ZaloEventMessage;
+  isSeen?: boolean;
+}): Promise<void> {
+  await sendZaloDeliveredEvent(params);
+}
+
+export async function sendSeenZalouser(params: {
+  profile?: string;
+  isGroup?: boolean;
+  message: ZaloEventMessage;
+}): Promise<void> {
+  await sendZaloSeenEvent(params);
+}
+
+function splitStyledText(
+  text: string,
+  styles: ZaloSendOptions["textStyles"],
+  limit: number,
+  mode: ZaloSendOptions["textChunkMode"],
+): StyledTextChunk[] {
+  if (text.length === 0) {
+    return [{ text, styles: undefined }];
+  }
+
+  const chunks: StyledTextChunk[] = [];
+  for (const range of splitTextRanges(text, limit, mode ?? DEFAULT_TEXT_CHUNK_MODE)) {
+    const { start, end } = range;
+    chunks.push({
+      text: text.slice(start, end),
+      styles: sliceTextStyles(styles, start, end),
+    });
+  }
+  return chunks;
+}
+
+function sliceTextStyles(
+  styles: ZaloSendOptions["textStyles"],
+  start: number,
+  end: number,
+): ZaloSendOptions["textStyles"] {
+  if (!styles || styles.length === 0) {
+    return undefined;
+  }
+
+  const chunkStyles = styles
+    .map((style) => {
+      const overlapStart = Math.max(style.start, start);
+      const overlapEnd = Math.min(style.start + style.len, end);
+      if (overlapEnd <= overlapStart) {
+        return null;
+      }
+
+      if (style.st === TextStyle.Indent) {
+        return {
+          start: overlapStart - start,
+          len: overlapEnd - overlapStart,
+          st: style.st,
+          indentSize: style.indentSize,
+        };
+      }
+
+      return {
+        start: overlapStart - start,
+        len: overlapEnd - overlapStart,
+        st: style.st,
+      };
+    })
+    .filter((style): style is NonNullable<typeof style> => style !== null);
+
+  return chunkStyles.length > 0 ? chunkStyles : undefined;
+}
+
+function splitTextRanges(
+  text: string,
+  limit: number,
+  mode: TextChunkMode,
+): Array<{ start: number; end: number }> {
+  if (mode === "newline") {
+    return splitTextRangesByPreferredBreaks(text, limit);
+  }
+
+  const ranges: Array<{ start: number; end: number }> = [];
+  for (let start = 0; start < text.length; start += limit) {
+    ranges.push({
+      start,
+      end: Math.min(text.length, start + limit),
+    });
+  }
+  return ranges;
+}
+
+function splitTextRangesByPreferredBreaks(
+  text: string,
+  limit: number,
+): Array<{ start: number; end: number }> {
+  const ranges: Array<{ start: number; end: number }> = [];
+  let start = 0;
+
+  while (start < text.length) {
+    const maxEnd = Math.min(text.length, start + limit);
+    let end = maxEnd;
+    if (maxEnd < text.length) {
+      end =
+        findParagraphBreak(text, start, maxEnd) ??
+        findLastBreak(text, "\n", start, maxEnd) ??
+        findLastWhitespaceBreak(text, start, maxEnd) ??
+        maxEnd;
+    }
+
+    if (end <= start) {
+      end = maxEnd;
+    }
+
+    ranges.push({ start, end });
+    start = end;
+  }
+
+  return ranges;
+}
+
+function findParagraphBreak(text: string, start: number, end: number): number | undefined {
+  const slice = text.slice(start, end);
+  const matches = slice.matchAll(/\n[\t ]*\n+/g);
+  let lastMatch: RegExpMatchArray | undefined;
+  for (const match of matches) {
+    lastMatch = match;
+  }
+  if (!lastMatch || lastMatch.index === undefined) {
+    return undefined;
+  }
+  return start + lastMatch.index + lastMatch[0].length;
+}
+
+function findLastBreak(
+  text: string,
+  marker: string,
+  start: number,
+  end: number,
+): number | undefined {
+  const index = text.lastIndexOf(marker, end - 1);
+  if (index < start) {
+    return undefined;
+  }
+  return index + marker.length;
+}
+
+function findLastWhitespaceBreak(text: string, start: number, end: number): number | undefined {
+  for (let index = end - 1; index > start; index -= 1) {
+    if (/\s/.test(text[index])) {
+      return index + 1;
+    }
+  }
+  return undefined;
+}