@solufy/evolution-sdk/lib/modules/chats/index.js

Unofficial SDK for the Evolution Whatsapp API v2

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/modules/chats/index.ts
var chats_exports = {};
__export(chats_exports, {
  ChatsModule: () => ChatsModule
});
module.exports = __toCommonJS(chats_exports);

// src/api/routes.ts
var Routes = {
  Message: {
    SendText: "message/sendText",
    SendMedia: "message/sendMedia",
    SendVoice: "message/sendWhatsAppAudio",
    SendSticker: "message/sendSticker",
    SendLocation: "message/sendLocation",
    SendContact: "message/sendContact",
    SendPoll: "message/sendPoll"
  },
  Chats: {
    Check: "chat/whatsappNumbers",
    FindAll: "chat/findChats",
    SendPresence: "chat/sendPresence"
  },
  Groups: {
    FindAll: "group/fetchAllGroups",
    FindByJid: "group/findGroupInfos",
    FindByInviteCode: "group/inviteInfo"
  }
};

// src/modules/chats/schemas/check.ts
var import_libphonenumber_js2 = require("libphonenumber-js");
var import_zod2 = require("zod");

// src/schemas/common.ts
var import_libphonenumber_js = require("libphonenumber-js");
var import_zod = require("zod");
var PhoneNumberSchema = import_zod.z.custom((value) => (0, import_libphonenumber_js.isValidPhoneNumber)(value), "Invalid phone number").transform((phoneNumber) => (0, import_libphonenumber_js.parsePhoneNumber)(phoneNumber).number);
var JidSchema = import_zod.z.string().endsWith(
  "@s.whatsapp.net",
  "Invalid remote JID, should end with @s.whatsapp.net"
);
var GroupJidSchema = import_zod.z.string().endsWith(
  "@g.us",
  "Invalid group JID, should end with @g.us"
);
var GroupInviteCodeSchema = import_zod.z.string().length(22).regex(
  /^[a-zA-Z0-9]{22}$/,
  "Invalid group invite code"
);
var ApiNumberSchema = import_zod.z.union([
  PhoneNumberSchema,
  JidSchema,
  GroupJidSchema
]);
var mediaSchema = import_zod.z.union([import_zod.z.string().url(), import_zod.z.string().base64()]);

// src/types/tags.ts
var Jid = (jid) => jid;
var GroupJid = (jid) => jid;
var ChatId = (id) => id;

// src/modules/chats/schemas/check.ts
var CheckOptionsSchema = import_zod2.z.array(PhoneNumberSchema);
var CheckBodySchema = CheckOptionsSchema.transform((data) => ({
  numbers: Array.isArray(data) ? data : [data]
}));
var CheckResponseSchema = import_zod2.z.array(
  import_zod2.z.object({
    exists: import_zod2.z.boolean(),
    jid: import_zod2.z.string(),
    number: import_zod2.z.string()
  })
).transform(
  (numbers) => numbers.map((number) => ({
    exists: number.exists,
    jid: Jid(number.jid),
    number: (0, import_libphonenumber_js2.parsePhoneNumber)(number.number).number
  }))
);

// src/modules/chats/schemas/find-all.ts
var import_zod3 = require("zod");

// src/utils/phone-numer-from-jid.ts
var import_libphonenumber_js3 = require("libphonenumber-js");
function phoneNumberFromJid(jid) {
  return (0, import_libphonenumber_js3.parsePhoneNumber)(`+${jid.split("@")[0]}`).number;
}

// src/modules/chats/schemas/find-all.ts
var FindAllChatsResponseSchema = import_zod3.z.array(
  import_zod3.z.object({
    id: import_zod3.z.string(),
    remoteJid: import_zod3.z.string(),
    name: import_zod3.z.string().nullish(),
    labels: import_zod3.z.array(import_zod3.z.string()).nullish(),
    createdAt: import_zod3.z.coerce.date(),
    updatedAt: import_zod3.z.coerce.date(),
    pushName: import_zod3.z.string().nullish(),
    profilePicUrl: import_zod3.z.string().url().nullish()
  })
).transform(
  (chats) => chats.map((chat) => ({
    id: ChatId(chat.id),
    jid: chat.remoteJid.endsWith("@g.us") ? GroupJid(chat.remoteJid) : Jid(chat.remoteJid),
    phoneNumber: phoneNumberFromJid(chat.remoteJid),
    name: chat.name || void 0,
    labels: chat.labels || void 0,
    createdAt: chat.createdAt,
    updatedAt: chat.updatedAt,
    pushName: chat.pushName || void 0,
    pictureUrl: chat.profilePicUrl || void 0
  }))
);

// src/modules/chats/schemas/presence.ts
var import_zod4 = require("zod");
var PresenceOptionsSchema = import_zod4.z.object({
  /**
   * Chat number or JID to receve the presence
   */
  number: ApiNumberSchema,
  /**
   * Duration of the presence in millisseconds
   */
  duration: import_zod4.z.number(),
  /**
   * Presence state
   * - `composing`: typing a message
   * - `recording`: recording an audio
   */
  presence: import_zod4.z.enum(["composing", "recording"]),
  /**
   * Whether to wait until the presence is finished (duration)
   */
  waitUntilFinish: import_zod4.z.boolean().optional()
});
var PresenceBodySchema = PresenceOptionsSchema.transform(
  ({ waitUntilFinish, duration, ...data }) => ({ ...data, delay: duration })
);

// src/modules/chats/index.ts
var ChatsModule = class {
  constructor(api) {
    this.api = api;
  }
  /**
   * Checks if a number has WhatsApp
   * @param numbers - Number(s) (with country code) to check
   */
  async check(...numbers) {
    const body = CheckBodySchema.parse(numbers.flat());
    const response = await this.api.post(Routes.Chats.Check, { body });
    return CheckResponseSchema.parse(response);
  }
  /**
   * Gets all chats
   */
  async findAll() {
    const response = await this.api.post(Routes.Chats.FindAll);
    return FindAllChatsResponseSchema.parse(response);
  }
  /**
   * Sends a presence to a certain chat
   * @param options - Presence options
   */
  async sendPresence(options) {
    const body = PresenceBodySchema.parse(options);
    if (options.waitUntilFinish) {
      await this.api.post(Routes.Chats.SendPresence, { body });
    } else {
      this.api.post(Routes.Chats.SendPresence, { body });
    }
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ChatsModule
});
//# sourceMappingURL=index.js.map