grammy-broadcast 2.0.2

package/dist/index.js

@@ -0,0 +1,884 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } var _class; var _class2; var _class3;// src/middleware.ts
+var _grammy = require('grammy');
+
+// src/utils.ts
+function sleep(milli) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milli);
+  });
+}
+function buildProgressBtnText(percent, chars = 10) {
+  let progress = Math.floor(percent * chars);
+  let empty = chars - progress;
+  console.log({ progress, empty });
+  return "\u2588".repeat(progress) + "\u2591".repeat(empty) + ` (${Math.floor(percent * 1e3) / 10}%)`;
+}
+function buildProgressText(error, sent, total, rateLimit) {
+  const rateText = rateLimit !== void 0 ? `
+\u26A1 Rate: ${rateLimit} msg/sec` : "";
+  return `\u231B Progress: ${error + sent}/${total}
+\u2705 Sent: ${sent}
+\u274C Error: ${error} (${Math.floor(error / total * 1e4) / 100}%)${rateText}`;
+}
+
+// src/middleware.ts
+function getMiddleware(options) {
+  var _a;
+  const middleware = new (0, _grammy.Composer)();
+  let broadcastMiddleware;
+  if ((_a = options.sudoUsers) == null ? void 0 : _a.length) {
+    broadcastMiddleware = middleware.filter((ctx) => {
+      var _a2;
+      if ((_a2 = ctx.from) == null ? void 0 : _a2.id) {
+        return options.sudoUsers.includes(ctx.from.id);
+      }
+      return false;
+    });
+  } else if (typeof options.hasPermission === "function") {
+    broadcastMiddleware = middleware.filter(options.hasPermission);
+  } else {
+    broadcastMiddleware = middleware;
+  }
+  broadcastMiddleware.command([options.cmds.broadcast, options.cmds.copy, options.cmds.forward], async (ctx) => {
+    var _a2;
+    let [command, ...args] = ctx.message.text.substring(1).split(" ");
+    let type;
+    let filter;
+    if (command === options.cmds.broadcast) {
+      if (args.length < 1) {
+        return ctx.reply(`Usage: /${options.cmds.broadcast} <type> [filter]
+
+\`type\` should be copy or forward
+\`filter\` is anything that want to passed to getBroadcastChats
+`, {
+          parse_mode: "Markdown"
+        });
+      }
+      type = args[0];
+      filter = args.slice(1).join(" ");
+    } else if (command === options.cmds.copy) {
+      type = "copy";
+      filter = args.join(" ");
+    } else if (command === options.cmds.forward) {
+      type = "forward";
+      filter = args.join(" ");
+    }
+    if (!["copy", "forward"].includes(type)) {
+      return ctx.reply(`Invalid type ${type}`);
+    }
+    let brdId = Math.random().toString(36).substring(7);
+    if (!ctx.message.reply_to_message) {
+      return ctx.reply("Reply to a message");
+    }
+    await options.storage.hset(options.keyPrefix + "info:" + brdId, {
+      type,
+      chatFilter: filter,
+      message_ids: (_a2 = ctx.message.reply_to_message) == null ? void 0 : _a2.message_id.toString(),
+      chat_id: ctx.chat.id.toString(),
+      user_id: ctx.from.id.toString(),
+      id: brdId,
+      error: "0",
+      sent: "0",
+      botId: ctx.me.id.toString(),
+      total: "-1"
+    });
+    return ctx.reply(`
+Ready to broadcast!
+currently 1 message is in queue
+for send multi message in this broadcast reply this command to another message
+<code>/${options.cmds.addmsg} ${brdId}</code>
+`, {
+      parse_mode: "HTML",
+      reply_markup: new (0, _grammy.InlineKeyboard)().text("Preview", "brd:preview:" + brdId).text("Pin", `brd:pin:${brdId}`).row().text("Start", "brd:start:" + brdId).text("Cancel", "brd:stop:" + brdId)
+    });
+  });
+  broadcastMiddleware.command(options.cmds.addmsg, async (ctx) => {
+    var _a2;
+    let args = ctx.message.text.split(" ").slice(1);
+    if (args.length < 1) {
+      return ctx.reply(`Usage: /${options.cmds.addmsg} <id>`);
+    }
+    let brdId = args[0];
+    if (!ctx.message.reply_to_message) {
+      return ctx.reply("Reply to a message");
+    }
+    let newMsgId = (_a2 = ctx.message.reply_to_message) == null ? void 0 : _a2.message_id;
+    let messageIds = await options.storage.hget(options.keyPrefix + "info:" + brdId, "message_ids");
+    if (!messageIds) {
+      return ctx.reply("Broadcast not found");
+    }
+    let currentIds = messageIds.split("_").map((e) => Number.parseInt(e));
+    if (Math.max(newMsgId, ...currentIds) !== newMsgId) {
+      return ctx.reply("Message should be newer than previous messages");
+    }
+    if (currentIds.includes(newMsgId)) {
+      return ctx.reply("Message already in queue");
+    }
+    currentIds.push(newMsgId);
+    await options.storage.hset(options.keyPrefix + "info:" + brdId, "message_ids", currentIds.join("_"));
+    let isPin = await options.storage.hget(options.keyPrefix + "info:" + brdId, "pin");
+    return ctx.reply(`Message added to queue
+
+Messages Count ${currentIds.length}`, {
+      reply_markup: new (0, _grammy.InlineKeyboard)().text("Preview", "brd:preview:" + brdId).text(`Pin${isPin ? " \u2705" : ""}`, `brd:pin:${brdId}`).row().text("Start", "brd:start:" + brdId).text("Cancel", "brd:stop:" + brdId)
+    });
+  });
+  broadcastMiddleware.callbackQuery(/brd:progress:(\w+)/, async (ctx) => {
+    let info = await options.storage.hgetall(options.keyPrefix + "info:" + ctx.match[1]);
+    return ctx.answerCallbackQuery(
+      {
+        text: buildProgressText(+info.error, +info.sent, +info.total),
+        show_alert: true
+      }
+    );
+  });
+  broadcastMiddleware.callbackQuery(/brd:pause:(\w+)/, async (ctx) => {
+    await options.storage.hset(options.keyPrefix + "info:" + ctx.match[1], "paused", "1");
+    return ctx.editMessageText("Broadcast paused!", {
+      reply_markup: new (0, _grammy.InlineKeyboard)().text("Resume", "brd:resume:" + ctx.match[1]).text("Stop", "brd:stop:" + ctx.match[1])
+    });
+  });
+  broadcastMiddleware.callbackQuery(/brd:resume:(\w+)/, async (ctx) => {
+    await options.storage.hdel(options.keyPrefix + "info:" + ctx.match[1], "paused");
+    return ctx.editMessageText(
+      "Lets begin...",
+      {
+        reply_markup: new (0, _grammy.InlineKeyboard)().text("Pause", "brd:pause:" + ctx.match[1]).text("Stop", "brd:stop:" + ctx.match[1])
+      }
+    );
+  });
+  broadcastMiddleware.callbackQuery(/brd:pin:(\w+)/, async (ctx) => {
+    let brdId = ctx.match[1];
+    let isPin = await options.storage.hget(options.keyPrefix + "info:" + brdId, "pin");
+    if (isPin) {
+      await options.storage.hdel(options.keyPrefix + "info:" + brdId, "pin");
+    } else {
+      await options.storage.hset(options.keyPrefix + "info:" + brdId, "pin", "1");
+    }
+    return ctx.editMessageReplyMarkup({
+      reply_markup: new (0, _grammy.InlineKeyboard)().text("Preview", "brd:preview:" + brdId).text(`Pin${!isPin ? " \u2705" : ""}`, `brd:pin:${brdId}`).row().text("Start", "brd:start:" + brdId).text("Cancel", "brd:stop:" + brdId)
+    });
+  });
+  broadcastMiddleware.callbackQuery(/brd:preview:(\w+)/, async (ctx) => {
+    let info = await options.storage.hgetall(options.keyPrefix + "info:" + ctx.match[1]);
+    if (!info.message_ids) {
+      return;
+    }
+    let messageIds = info.message_ids.split("_").map((e) => Number.parseInt(e));
+    if (info.type === "copy") {
+      let msgs = await ctx.copyMessages(info.chat_id, messageIds);
+      if (info.pin) {
+        await ctx.pinChatMessage(msgs.pop().message_id);
+      }
+    } else if (info.type === "forward") {
+      let msgs = await ctx.forwardMessages(info.chat_id, messageIds);
+      if (info.pin) {
+        await ctx.pinChatMessage(msgs.pop().message_id);
+      }
+    }
+  });
+  broadcastMiddleware.callbackQuery(/brd:start:(\w+)/, async (ctx) => {
+    let id = ctx.match[1];
+    await options.storage.rpush(options.keyPrefix + "list", id);
+    return ctx.editMessageText(`Broadcast added to queue it takes some time to start...`, {
+      reply_markup: new (0, _grammy.InlineKeyboard)().text("Pause", "brd:pause:" + id).text("Stop", "brd:stop:" + id)
+    });
+  });
+  broadcastMiddleware.callbackQuery(/brd:stop:(\w+)/, async (ctx) => {
+    return ctx.editMessageReplyMarkup({
+      reply_markup: new (0, _grammy.InlineKeyboard)().text("Sure?").row().text("Yes", "brd:stop_confirm:" + ctx.match[1]).text("No", `brd:stop_cancel:${ctx.match[1]}`)
+    });
+  });
+  broadcastMiddleware.callbackQuery(/brd:stop_cancel/, async (ctx) => {
+    return ctx.editMessageReplyMarkup(
+      {
+        reply_markup: new (0, _grammy.InlineKeyboard)().text("Pause", "brd:pause:" + ctx.match[1])
+      }
+    );
+  });
+  broadcastMiddleware.callbackQuery(/brd:stop_confirm:(\w+)/, async (ctx) => {
+    let id = ctx.match[1];
+    await options.storage.del(options.keyPrefix + "chats:" + id);
+    await options.storage.del(options.keyPrefix + "info:" + id);
+    await options.storage.lrem(options.keyPrefix + "list", 1, id);
+    return ctx.editMessageText("Broadcast stopped");
+  });
+  return middleware;
+}
+
+// src/broadcast.queue.ts
+
+
+// src/initChats.queue.ts
+var ChatsFetcher = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async fetchChats(broadcast, progressCallback) {
+    let chatOffset = +(broadcast.chatOffset || "0");
+    if (progressCallback) {
+      await progressCallback(broadcast);
+    }
+    while (true) {
+      let chatIds = await this.options.getBroadcastChats(+broadcast.botId, chatOffset, this.options.chunkSize, broadcast.chatFilter);
+      await this.options.storage.rpush(this.options.keyPrefix + "chats:" + broadcast.id, ...chatIds.map(String));
+      chatOffset += chatIds.length;
+      broadcast.chatOffset = chatOffset.toString();
+      await this.options.storage.hset(this.options.keyPrefix + "info:" + broadcast.id, "chatOffset", chatOffset.toString());
+      if (progressCallback) {
+        await progressCallback(broadcast);
+      }
+      if (chatIds.length < this.options.chunkSize) {
+        await this.options.storage.hset(this.options.keyPrefix + "info:" + broadcast.id, "total", chatOffset.toString());
+        broadcast.total = chatOffset.toString();
+        break;
+      }
+    }
+  }
+};
+
+// src/broadcast.queue.ts
+var RateLimiter = (_class = class {
+  __init() {this.queue = []}
+  
+  
+  
+  
+  __init2() {this.refillTimer = null}
+  __init3() {this.lastRefillTime = Date.now()}
+  constructor(requestsPerSecond) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.initialMaxTokens = requestsPerSecond;
+    this.maxTokens = requestsPerSecond;
+    this.tokens = requestsPerSecond;
+    this.refillInterval = requestsPerSecond >= 100 ? 10 : 100;
+    this.startRefill();
+  }
+  getCurrentRate() {
+    return this.maxTokens;
+  }
+  reduceRate(factor = 0.5) {
+    const newRate = Math.max(1, Math.floor(this.maxTokens * factor));
+    console.log(`Reducing rate limit from ${this.maxTokens}/sec to ${newRate}/sec`);
+    this.maxTokens = newRate;
+    this.refillInterval = newRate >= 100 ? 10 : 100;
+    this.tokens = Math.min(this.tokens, this.maxTokens);
+  }
+  resetRate() {
+    if (this.maxTokens !== this.initialMaxTokens) {
+      console.log(`Resetting rate limit from ${this.maxTokens}/sec to ${this.initialMaxTokens}/sec`);
+      this.maxTokens = this.initialMaxTokens;
+      this.refillInterval = this.initialMaxTokens >= 100 ? 10 : 100;
+      this.tokens = Math.min(this.tokens, this.maxTokens);
+    }
+  }
+  startRefill() {
+    if (this.refillTimer) return;
+    this.refillTimer = setInterval(() => {
+      const now = Date.now();
+      const elapsed = now - this.lastRefillTime;
+      const tokensToAdd = Math.floor(this.maxTokens * elapsed / 1e3);
+      if (tokensToAdd > 0) {
+        this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+        this.lastRefillTime = now;
+        this.processQueue();
+      }
+    }, this.refillInterval);
+  }
+  processQueue() {
+    while (this.queue.length > 0 && this.tokens > 0) {
+      this.tokens--;
+      const resolve = this.queue.shift();
+      resolve();
+    }
+  }
+  async acquire() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefillTime;
+    if (elapsed >= 1e3) {
+      this.tokens = this.maxTokens;
+      this.lastRefillTime = now;
+    } else if (elapsed > 0) {
+      const tokensToAdd = Math.floor(this.maxTokens * elapsed / 1e3);
+      if (tokensToAdd > 0) {
+        this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+        this.lastRefillTime = now;
+      }
+    }
+    if (this.tokens > 0) {
+      this.tokens--;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  destroy() {
+    if (this.refillTimer) {
+      clearInterval(this.refillTimer);
+      this.refillTimer = null;
+    }
+  }
+}, _class);
+var BroadcastQueue = (_class2 = class {
+  constructor(options) {;_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);
+    this.options = options;
+    const requestsPerSecond = this.options.allowPaidBroadcast ? 1e3 : 30;
+    this.rateLimiter = new RateLimiter(requestsPerSecond);
+  }
+  __init4() {this.reportIds = {}}
+  __init5() {this.lastReports = {}}
+  __init6() {this.processingBroadcasts = /* @__PURE__ */ new Set()}
+  
+  __init7() {this.lastRateLimitTime = 0}
+  async checkBroadcasts() {
+    let broadcasts = await this.options.storage.lrange(this.options.keyPrefix + "list", 0, -1);
+    let newBroadcasts = broadcasts.filter((id) => !this.processingBroadcasts.has(id));
+    if (newBroadcasts.length > 0) {
+      newBroadcasts.forEach((id) => this.processingBroadcasts.add(id));
+      Promise.all(newBroadcasts.map(
+        (broadcastId) => this.sendBroadcast(broadcastId).finally(() => {
+          this.processingBroadcasts.delete(broadcastId);
+        })
+      )).catch((err) => {
+        console.error("Error processing broadcasts:", err);
+      });
+    }
+    setTimeout(this.checkBroadcasts.bind(this), this.options.checkQueueInterval);
+  }
+  async sendBroadcast(id) {
+    let broadcastInfo = await this.options.storage.hgetall(this.options.keyPrefix + "info:" + id);
+    if (broadcastInfo.total === "-1") {
+      console.log("fetching chats");
+      let fetcher = new ChatsFetcher(this.options);
+      await fetcher.fetchChats(broadcastInfo, async (info) => {
+        await this.sendProgress(info, false, "fetching");
+      });
+      broadcastInfo = await this.options.storage.hgetall(this.options.keyPrefix + "info:" + id);
+    }
+    if (!broadcastInfo) {
+      await this.options.storage.lrem(this.options.keyPrefix + "list", 1, id);
+      return;
+    }
+    let chats = await this.options.storage.lpop(this.options.keyPrefix + "chats:" + id, this.options.chunkSize);
+    if (broadcastInfo.paused) return;
+    if (!(chats == null ? void 0 : chats.length)) {
+      await this.options.storage.del(this.options.keyPrefix + "chats:" + id);
+      await this.options.storage.del(this.options.keyPrefix + "info:" + id);
+      await this.options.storage.lrem(this.options.keyPrefix + "list", 1, id);
+      await this.sendProgress(broadcastInfo, true);
+      return;
+    }
+    broadcastInfo.sent = broadcastInfo.sent || "0";
+    broadcastInfo.error = broadcastInfo.error || "0";
+    const sendPromises = chats.map(async (chat) => {
+      await this.rateLimiter.acquire();
+      let isSent = await this.sendToChat(chat, broadcastInfo);
+      if (isSent) {
+        broadcastInfo.sent = (+broadcastInfo.sent + 1).toString();
+        await this.options.storage.hincrby(this.options.keyPrefix + "info:" + id, "sent", 1);
+      } else {
+        broadcastInfo.error = (+broadcastInfo.error + 1).toString();
+        await this.options.storage.hincrby(this.options.keyPrefix + "info:" + id, "error", 1);
+      }
+    });
+    await Promise.all(sendPromises);
+    await this.sendProgress(broadcastInfo);
+    await this.sendBroadcast(id);
+  }
+  async sendProgress(broadcastInfo, finished = false, stage = "broadcasting") {
+    if (this.options.progressCallback) {
+      this.options.progressCallback(
+        broadcastInfo.id,
+        +broadcastInfo.sent || 0,
+        +broadcastInfo.error || 0,
+        +broadcastInfo.total || 0
+      );
+      return;
+    }
+    let api = await this.options.getApi(+broadcastInfo.botId);
+    let progressText;
+    let percent;
+    let title;
+    if (stage === "fetching") {
+      let chatOffset = +(broadcastInfo.chatOffset || "0");
+      let currentTotal = broadcastInfo.total === "-1" ? chatOffset : +broadcastInfo.total;
+      progressText = `\u{1F50D} Fetching chats...
+\u{1F4CA} Chats fetched: ${chatOffset}/${currentTotal}`;
+      percent = 0;
+      title = "\u{1F50D} Fetching Chats";
+    } else {
+      let error = +broadcastInfo.error || 0;
+      let sent = +broadcastInfo.sent || 0;
+      let total = +broadcastInfo.total || 0;
+      percent = total > 0 ? (error + sent) / total : 0;
+      const currentRate = this.rateLimiter.getCurrentRate();
+      progressText = buildProgressText(error, sent, total, currentRate);
+      title = finished ? "\u2705 Broadcast Finished" : "\u231B Broadcasting";
+    }
+    let replyMarkup = new (0, _grammy.InlineKeyboard)().text(buildProgressBtnText(percent), `brd:progress:${broadcastInfo.id}`).row().text("Pause", `brd:pause:${broadcastInfo.id}`).text("Stop", `brd:stop:${broadcastInfo.id}`);
+    if (finished) {
+      await api.sendMessage(broadcastInfo.chat_id, `${title}
+${progressText}`);
+      return;
+    }
+    let msgId = this.reportIds[broadcastInfo.id];
+    if (!msgId) {
+      let msg = await api.sendMessage(broadcastInfo.chat_id, `${title}
+${progressText}`, {
+        reply_markup: replyMarkup
+      });
+      this.reportIds[broadcastInfo.id] = msg.message_id;
+      this.lastReports[broadcastInfo.id] = /* @__PURE__ */ new Date();
+    } else {
+      let lastReport = this.lastReports[broadcastInfo.id];
+      if (lastReport && Date.now() - lastReport.getTime() < this.options.reportFrequency) {
+        return;
+      }
+      await api.editMessageText(broadcastInfo.chat_id, msgId, `${title}
+${progressText}`, {
+        reply_markup: replyMarkup
+      });
+      this.lastReports[broadcastInfo.id] = /* @__PURE__ */ new Date();
+    }
+  }
+  async sendToChat(chatId, broadcastInfo) {
+    var _a;
+    let msgIds = (_a = broadcastInfo.message_ids) == null ? void 0 : _a.split("_").map((e) => parseInt(e));
+    let api = await this.options.getApi(+broadcastInfo.botId);
+    try {
+      let msgId;
+      const paidBroadcastOptions = this.options.allowPaidBroadcast ? { allow_paid_broadcast: true } : {};
+      if (broadcastInfo.type === "text") {
+        let msg = await api.sendMessage(chatId, broadcastInfo.text, paidBroadcastOptions);
+        msgId = msg.message_id;
+      } else if (broadcastInfo.type === "forward") {
+        let msgs = await api.forwardMessages(chatId, broadcastInfo.chat_id, msgIds, paidBroadcastOptions);
+        msgId = msgs.pop().message_id;
+      } else if (broadcastInfo.type === "copy") {
+        let msgs = await api.copyMessages(chatId, broadcastInfo.chat_id, msgIds, paidBroadcastOptions);
+        msgId = msgs.pop().message_id;
+      }
+      if (broadcastInfo.pin) {
+        await api.pinChatMessage(chatId, msgId, { disable_notification: true, ...paidBroadcastOptions });
+      }
+      return true;
+    } catch (err) {
+      let retry = await this.handleError(+broadcastInfo.botId, chatId, err);
+      if (retry) {
+        await this.sendToChat(chatId, broadcastInfo);
+        return true;
+      }
+      return false;
+    }
+  }
+  async handleError(botId, chatId, error) {
+    var _a;
+    try {
+      const message = "description" in error ? error.description : error.message;
+      const errorMessage = message.toLowerCase();
+      const setRestricted = ((_a = this.options.setRestricted) == null ? void 0 : _a.bind(null, botId, chatId)) || ((reason) => {
+        console.log(`ChatId: ${chatId} is restricted for reason: ${reason} you didn't handled this error`);
+      });
+      if (errorMessage.includes("blocked")) {
+        setRestricted("block");
+      }
+      if (errorMessage.includes("deactivated")) {
+        setRestricted("deactivated");
+      }
+      if (errorMessage.includes("kicked")) {
+        setRestricted("banned");
+      }
+      if (errorMessage.includes("restricted")) {
+        setRestricted("restricted");
+      }
+      if (errorMessage.includes("initiate conversation")) {
+        setRestricted("no-conv");
+      }
+      if ("parameters" in error) {
+        if (error.parameters.retry_after) {
+          const retryAfter = error.parameters.retry_after;
+          console.log(`Rate limited by Telegram for ${retryAfter} secs`);
+          await sleep(retryAfter * 1e3);
+          const now = Date.now();
+          const timeSinceLastLimit = now - this.lastRateLimitTime;
+          this.lastRateLimitTime = now;
+          if (timeSinceLastLimit < 6e4) {
+            this.rateLimiter.reduceRate(0.5);
+          } else {
+            this.rateLimiter.reduceRate(0.7);
+          }
+          return true;
+        }
+      }
+    } catch (err) {
+      console.log("HandlerError error: ", err);
+    } finally {
+    }
+    return false;
+  }
+}, _class2);
+
+// src/storage.ts
+var Storage = class {
+};
+
+// src/storage/redis.storage.ts
+var RedisStorage = class extends Storage {
+  constructor(redis) {
+    super();
+    this.redis = redis;
+  }
+  async lrange(key, start, end) {
+    return await this.redis.lrange(key, start, end);
+  }
+  async hgetall(key) {
+    return await this.redis.hgetall(key);
+  }
+  async lrem(key, count, value) {
+    await this.redis.lrem(key, count, value);
+  }
+  async lpop(key, count) {
+    const result = await this.redis.lpop(key, count);
+    if (result === null) return null;
+    return Array.isArray(result) ? result : [result];
+  }
+  async del(...keys) {
+    await this.redis.del(...keys);
+  }
+  async hincrby(key, field, increment) {
+    await this.redis.hincrby(key, field, increment);
+  }
+  async hset(key, fieldOrObject, value) {
+    if (typeof fieldOrObject === "string") {
+      await this.redis.hset(key, fieldOrObject, value);
+    } else {
+      await this.redis.hset(key, fieldOrObject);
+    }
+  }
+  async hget(key, field) {
+    return await this.redis.hget(key, field);
+  }
+  async hdel(key, ...fields) {
+    await this.redis.hdel(key, ...fields);
+  }
+  async rpush(key, ...values) {
+    await this.redis.rpush(key, ...values);
+  }
+};
+
+// src/storage/memory.storage.ts
+var MemoryStorage = (_class3 = class extends Storage {constructor(...args2) { super(...args2); _class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this); }
+  __init8() {this.lists = /* @__PURE__ */ new Map()}
+  __init9() {this.hashes = /* @__PURE__ */ new Map()}
+  async lrange(key, start, end) {
+    const list = this.lists.get(key) || [];
+    const actualEnd = end === -1 ? list.length : end + 1;
+    return list.slice(start, actualEnd);
+  }
+  async hgetall(key) {
+    const hash = this.hashes.get(key);
+    if (!hash) return {};
+    const result = {};
+    hash.forEach((value, field) => {
+      result[field] = value;
+    });
+    return result;
+  }
+  async lrem(key, count, value) {
+    const list = this.lists.get(key);
+    if (!list) return;
+    if (count === 0) {
+      const filtered = list.filter((item) => item !== value);
+      this.lists.set(key, filtered);
+    } else if (count > 0) {
+      let removed = 0;
+      const filtered = list.filter((item) => {
+        if (item === value && removed < count) {
+          removed++;
+          return false;
+        }
+        return true;
+      });
+      this.lists.set(key, filtered);
+    } else {
+      let removed = 0;
+      const filtered = list.reverse().filter((item) => {
+        if (item === value && removed < Math.abs(count)) {
+          removed++;
+          return false;
+        }
+        return true;
+      }).reverse();
+      this.lists.set(key, filtered);
+    }
+  }
+  async lpop(key, count) {
+    const list = this.lists.get(key);
+    if (!list || list.length === 0) return null;
+    const popped = list.splice(0, count);
+    if (list.length === 0) {
+      this.lists.delete(key);
+    }
+    return popped;
+  }
+  async del(...keys) {
+    for (const key of keys) {
+      this.lists.delete(key);
+      this.hashes.delete(key);
+    }
+  }
+  async hincrby(key, field, increment) {
+    let hash = this.hashes.get(key);
+    if (!hash) {
+      hash = /* @__PURE__ */ new Map();
+      this.hashes.set(key, hash);
+    }
+    const currentValue = hash.get(field) || "0";
+    const newValue = (parseInt(currentValue, 10) + increment).toString();
+    hash.set(field, newValue);
+  }
+  async hset(key, fieldOrObject, value) {
+    let hash = this.hashes.get(key);
+    if (!hash) {
+      hash = /* @__PURE__ */ new Map();
+      this.hashes.set(key, hash);
+    }
+    if (typeof fieldOrObject === "string") {
+      hash.set(fieldOrObject, value);
+    } else {
+      Object.entries(fieldOrObject).forEach(([field, val]) => {
+        hash.set(field, val);
+      });
+    }
+  }
+  async hget(key, field) {
+    const hash = this.hashes.get(key);
+    if (!hash) return null;
+    return hash.get(field) || null;
+  }
+  async hdel(key, ...fields) {
+    const hash = this.hashes.get(key);
+    if (!hash) return;
+    fields.forEach((field) => hash.delete(field));
+    if (hash.size === 0) {
+      this.hashes.delete(key);
+    }
+  }
+  async rpush(key, ...values) {
+    let list = this.lists.get(key);
+    if (!list) {
+      list = [];
+      this.lists.set(key, list);
+    }
+    list.push(...values);
+  }
+}, _class3);
+
+// src/storage/file.storage.ts
+var _promises = require('fs/promises'); var fs = _interopRequireWildcard(_promises);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var FileStorage = class extends Storage {
+  
+  constructor(baseDir = "./broadcast-storage") {
+    super();
+    this.baseDir = baseDir;
+  }
+  async ensureDir() {
+    try {
+      await fs.mkdir(this.baseDir, { recursive: true });
+    } catch (error) {
+    }
+  }
+  getListPath(key) {
+    return path.join(this.baseDir, `list_${key.replace(/[^a-zA-Z0-9]/g, "_")}.json`);
+  }
+  getHashPath(key) {
+    return path.join(this.baseDir, `hash_${key.replace(/[^a-zA-Z0-9]/g, "_")}.json`);
+  }
+  async readList(key) {
+    await this.ensureDir();
+    const filePath = this.getListPath(key);
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return [];
+    }
+  }
+  async writeList(key, list) {
+    await this.ensureDir();
+    const filePath = this.getListPath(key);
+    if (list.length === 0) {
+      try {
+        await fs.unlink(filePath);
+      } catch (error) {
+      }
+    } else {
+      await fs.writeFile(filePath, JSON.stringify(list), "utf-8");
+    }
+  }
+  async readHash(key) {
+    await this.ensureDir();
+    const filePath = this.getHashPath(key);
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return {};
+    }
+  }
+  async writeHash(key, hash) {
+    await this.ensureDir();
+    const filePath = this.getHashPath(key);
+    if (Object.keys(hash).length === 0) {
+      try {
+        await fs.unlink(filePath);
+      } catch (error) {
+      }
+    } else {
+      await fs.writeFile(filePath, JSON.stringify(hash), "utf-8");
+    }
+  }
+  async lrange(key, start, end) {
+    const list = await this.readList(key);
+    const actualEnd = end === -1 ? list.length : end + 1;
+    return list.slice(start, actualEnd);
+  }
+  async hgetall(key) {
+    return await this.readHash(key);
+  }
+  async lrem(key, count, value) {
+    const list = await this.readList(key);
+    if (count === 0) {
+      const filtered = list.filter((item) => item !== value);
+      await this.writeList(key, filtered);
+    } else if (count > 0) {
+      let removed = 0;
+      const filtered = list.filter((item) => {
+        if (item === value && removed < count) {
+          removed++;
+          return false;
+        }
+        return true;
+      });
+      await this.writeList(key, filtered);
+    } else {
+      let removed = 0;
+      const filtered = list.reverse().filter((item) => {
+        if (item === value && removed < Math.abs(count)) {
+          removed++;
+          return false;
+        }
+        return true;
+      }).reverse();
+      await this.writeList(key, filtered);
+    }
+  }
+  async lpop(key, count) {
+    const list = await this.readList(key);
+    if (list.length === 0) return null;
+    const popped = list.splice(0, count);
+    await this.writeList(key, list);
+    return popped;
+  }
+  async del(...keys) {
+    for (const key of keys) {
+      const listPath = this.getListPath(key);
+      const hashPath = this.getHashPath(key);
+      try {
+        await fs.unlink(listPath);
+      } catch (error) {
+      }
+      try {
+        await fs.unlink(hashPath);
+      } catch (error) {
+      }
+    }
+  }
+  async hincrby(key, field, increment) {
+    const hash = await this.readHash(key);
+    const currentValue = hash[field] || "0";
+    hash[field] = (parseInt(currentValue, 10) + increment).toString();
+    await this.writeHash(key, hash);
+  }
+  async hset(key, fieldOrObject, value) {
+    const hash = await this.readHash(key);
+    if (typeof fieldOrObject === "string") {
+      hash[fieldOrObject] = value;
+    } else {
+      Object.assign(hash, fieldOrObject);
+    }
+    await this.writeHash(key, hash);
+  }
+  async hget(key, field) {
+    const hash = await this.readHash(key);
+    return hash[field] || null;
+  }
+  async hdel(key, ...fields) {
+    const hash = await this.readHash(key);
+    fields.forEach((field) => delete hash[field]);
+    await this.writeHash(key, hash);
+  }
+  async rpush(key, ...values) {
+    const list = await this.readList(key);
+    list.push(...values);
+    await this.writeList(key, list);
+  }
+};
+
+// src/index.ts
+var defaultOptions = {
+  chunkSize: 100,
+  keyPrefix: "brdc:",
+  reportFrequency: 60 * 1e3,
+  progressCallback: null,
+  setRestricted: null,
+  checkQueueInterval: 60 * 1e3,
+  hasPermission: null,
+  allowPaidBroadcast: false,
+  cmds: {
+    broadcast: "broadcast",
+    copy: "copy",
+    forward: "forward",
+    addmsg: "addmsg"
+  }
+};
+var Broadcaster = class _Broadcaster {
+  constructor(options) {
+    this.options = options;
+  }
+  
+  static getInstance(options) {
+    if (_Broadcaster._instance) {
+      return _Broadcaster._instance;
+    }
+    let instance = new _Broadcaster(options);
+    const queue = new BroadcastQueue(options);
+    queue.checkBroadcasts().then(() => {
+    });
+    _Broadcaster._instance = instance;
+    return instance;
+  }
+  getMiddleware() {
+    return getMiddleware(this.options);
+  }
+};
+function createBroadcaster(options) {
+  const allOptions = {
+    ...defaultOptions,
+    cmds: {
+      ...defaultOptions.cmds,
+      ...options.cmds
+    },
+    ...options
+  };
+  return Broadcaster.getInstance(allOptions);
+}
+
+
+
+
+
+
+exports.FileStorage = FileStorage; exports.MemoryStorage = MemoryStorage; exports.RedisStorage = RedisStorage; exports.Storage = Storage; exports.createBroadcaster = createBroadcaster;
+//# sourceMappingURL=index.js.map