@kodelyth/zalouser 2026.5.42 → 2026.6.2

package/src/send.test.ts

@@ -1,424 +0,0 @@
-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

@@ -1,280 +0,0 @@
-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;
-}