@skyzopedia/baileys-mod 5.0.8 → 6.0.1

package/lib/KeyDB/BinarySearch.js

@@ -1,20 +0,0 @@
-//===================================//
-export default function binarySearch(array, predicate) {
-  let low = 0;
-  let high = array.length;
-  if (array.length === 0) return low;
-  if (predicate(array[low]) < 0) return low - 1;
-  else if (predicate(array[low]) === 0) return low;
-  const maxPred = predicate(array[high - 1]);
-  if (maxPred > 0) return high;
-  else if (maxPred === 0) return high - 1;
-  while (low !== high) {
-    const mid = low + Math.floor((high - low) / 2);
-    const pred = predicate(array[mid]);
-    if (pred < 0) high = mid;
-    else if (pred > 0) low = mid + 1;
-    else return mid;
-  }
-  return low;
-}
-//===================================//

package/lib/KeyDB/KeyedDB.js

@@ -1,167 +0,0 @@
-//===================================//
-import binarySearch from "./BinarySearch.js";
-//===================================//
-export default class KeyedDB {
-  constructor(key, id) {
-    this.key = key;
-    this.idGetter = id || (v => this.key.key(v).toString());
-    this.dict = {};
-    this.array = [];
-  }
-  get length() {
-    return this.array.length;
-  }
-  get first() {
-    return this.array[0];
-  }
-  get last() {
-    return this.array[this.array.length - 1];
-  }
-  toJSON() {
-    return this.array;
-  }
-  insert(...values) {
-    values.forEach(v => this._insertSingle(v));
-  }
-  upsert(...values) {
-    const updates = [];
-    values.forEach(v => {
-      if (!v) return;
-      const deleted = this.deleteById(this.idGetter(v), false);
-      this._insertSingle(v);
-      deleted && updates.push(v);
-    });
-    return updates;
-  }
-  insertIfAbsent(...values) {
-    const insertions = [];
-    values.forEach(v => {
-      if (!v) return;
-      const presentValue = this.get(this.idGetter(v));
-      if (presentValue) return;
-      const presentKey = this.firstIndex(v);
-      if (this.array[presentKey] && this.key.key(this.array[presentKey]) === this.key.key(v)) return;
-      this.insert(v);
-      insertions.push(v);
-    });
-    return insertions;
-  }
-  deleteById(id, assertPresent = true) {
-    const value = this.get(id);
-    if (!value) {
-      if (assertPresent) throw new Error(`Value not found`);
-      return;
-    }
-    return this.delete(value);
-  }
-  delete(value) {
-    const index = this.firstIndex(value);
-    if (index < 0 || index >= this.array.length || this.key.key(value) !== this.key.key(this.array[index])) {
-      return null;
-    }
-    delete this.dict[this.idGetter(value)];
-    return this.array.splice(index, 1)[0];
-  }
-  slice(start, end) {
-    const db = new KeyedDB(this.key, this.idGetter);
-    db.array = this.array.slice(start, end);
-    db.array.forEach(item => db.dict[this.idGetter(item)] = item);
-    return db;
-  }
-  clear() {
-    this.array = [];
-    this.dict = {};
-  }
-  get(id) {
-    return this.dict[id];
-  }
-  all() {
-    return this.array;
-  }
-  update(id, update) {
-    const value = this.get(id);
-    if (value) {
-      const idx = this.firstIndex(value);
-      if (idx >= 0 && idx < this.array.length && this.idGetter(this.array[idx]) === id) {
-        const oldKey = this.key.key(value);
-        update(value);
-        const newKey = this.key.key(value);
-        if (newKey !== oldKey) {
-          delete this.dict[id];
-          this.array.splice(idx, 1);
-          this._insertSingle(value);
-          return 2;
-        }
-        return 1;
-      }
-    }
-  }
-  updateKey(value, update) {
-    return this.update(this.idGetter(value), update);
-  }
-  filter(predicate) {
-    const db = new KeyedDB(this.key, this.idGetter);
-    db.array = this.array.filter((value, index) => {
-      if (predicate(value, index)) {
-        db.dict[this.idGetter(value)] = value;
-        return true;
-      }
-    });
-    return db;
-  }
-  paginatedByValue(value, limit, predicate, mode = "after") {
-    return this.paginated(value && this.key.key(value), limit, predicate, mode);
-  }
-  paginated(cursor, limit, predicate, mode = "after") {
-    let index = mode === "after" ? 0 : this.array.length;
-    if (cursor !== null && typeof cursor !== "undefined") {
-      index = binarySearch(this.array, v => this.key.compare(cursor, this.key.key(v)));
-      if (index < 0) index = 0;
-      if (this.key.key(this.array[index]) === cursor) index += (mode === "after" ? 1 : 0);
-    }
-    return this.filtered(index, limit, mode, predicate);
-  }
-  _insertSingle(value) {
-    if (!value) throw new Error("falsey value");
-    const valueID = this.idGetter(value);
-    if (this.get(valueID)) throw new Error("duplicate ID being inserted: " + valueID);
-
-    if (this.array.length > 0) {
-      const index = this.firstIndex(value);
-      if (index >= this.array.length) this.array.push(value);
-      else if (index < 0) this.array.unshift(value);
-      else if (this.key.key(value) !== this.key.key(this.array[index])) this.array.splice(index, 0, value);
-      else throw new Error(`duplicate key: ${this.key.key(value)}, inserting: ${valueID}, present: ${this.idGetter(this.array[index])}`);
-    } else {
-      this.array.push(value);
-    }
-    this.dict[valueID] = value;
-  }
-  filtered(start, count, mode, predicate) {
-    let arr;
-    if (mode === "after") {
-      if (predicate) {
-        arr = [];
-        for (let item of this.array.slice(start)) {
-          predicate(item, start + arr.length) && arr.push(item);
-          if (arr.length >= count) break;
-        }
-      } else arr = this.array.slice(start, start + count);
-    } else if (mode === "before") {
-      if (predicate) {
-        arr = [];
-        for (let i = start - 1; i >= 0; i--) {
-          let item = this.array[i];
-          predicate(item, start + arr.length) && arr.unshift(item);
-          if (arr.length >= count) break;
-        }
-      } else arr = this.array.slice(Math.max(start - count, 0), start);
-    }
-    return arr;
-  }
-  firstIndex(value) {
-    const valueKey = this.key.key(value);
-    return binarySearch(this.array, v => this.key.compare(valueKey, this.key.key(v)));
-  }
-}
-//===================================//

package/lib/KeyDB/index.js

@@ -1,4 +0,0 @@
-//===================================//
-export * from "./BinarySearch.js"
-export * from "./KeyedDB.js"
-//===================================//

package/lib/Signal/lid-mapping.js

@@ -1,155 +0,0 @@
-//=======================================================//
-import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from "../WABinary/index.js";
-import { LRUCache } from "lru-cache";
-//=======================================================//
-export class LIDMappingStore {
-  constructor(keys, logger, pnToLIDFunc) {
-    this.mappingCache = new LRUCache({
-      ttl: 7 * 24 * 60 * 60 * 1000,
-      ttlAutopurge: true,
-      updateAgeOnGet: true
-    });
-    this.keys = keys;
-    this.pnToLIDFunc = pnToLIDFunc;
-    this.logger = logger;
-  }
-  async storeLIDPNMappings(pairs) {
-    const pairMap = {};
-    for (const { lid, pn } of pairs) {
-      if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
-        this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
-        continue;
-      }
-      const lidDecoded = jidDecode(lid);
-      const pnDecoded = jidDecode(pn);
-      if (!lidDecoded || !pnDecoded)
-        return;
-      const pnUser = pnDecoded.user;
-      const lidUser = lidDecoded.user;
-      let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
-      if (!existingLidUser) {
-        this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
-        const stored = await this.keys.get("lid-mapping", [pnUser]);
-        existingLidUser = stored[pnUser];
-        if (existingLidUser) {
-          this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
-          this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
-        }
-      }
-      if (existingLidUser === lidUser) {
-        this.logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
-        continue;
-      }
-      pairMap[pnUser] = lidUser;
-    }
-    this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
-    await this.keys.transaction(async () => {
-      for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-        await this.keys.set({
-          "lid-mapping": {
-            [pnUser]: lidUser,
-            [`${lidUser}_reverse`]: pnUser
-          }
-        });
-        this.mappingCache.set(`pn:${pnUser}`, lidUser);
-        this.mappingCache.set(`lid:${lidUser}`, pnUser);
-      }
-    }, "lid-mapping");
-  }
-  async getLIDForPN(pn) {
-    return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
-  }
-  async getLIDsForPNs(pns) {
-    const usyncFetch = {};
-    const successfulPairs = {};
-    for (const pn of pns) {
-      if (!isPnUser(pn) && !isHostedPnUser(pn))
-        continue;
-      const decoded = jidDecode(pn);
-      if (!decoded)
-        continue;
-      const pnUser = decoded.user;
-      let lidUser = this.mappingCache.get(`pn:${pnUser}`);
-      if (!lidUser) {
-        const stored = await this.keys.get("lid-mapping", [pnUser]);
-        lidUser = stored[pnUser];
-        if (lidUser) {
-          this.mappingCache.set(`pn:${pnUser}`, lidUser);
-          this.mappingCache.set(`lid:${lidUser}`, pnUser);
-        }
-        else {
-          this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
-          const device = decoded.device || 0;
-          let normalizedPn = jidNormalizedUser(pn);
-          if (isHostedPnUser(normalizedPn)) {
-            normalizedPn = `${pnUser}@s.whatsapp.net`;
-          }
-          if (!usyncFetch[normalizedPn]) {
-            usyncFetch[normalizedPn] = [device];
-          }
-          else {
-            usyncFetch[normalizedPn]?.push(device);
-          }
-          continue;
-        }
-      }
-      lidUser = lidUser.toString();
-      if (!lidUser) {
-        this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
-        return null;
-      }
-      const pnDevice = decoded.device !== undefined ? decoded.device : 0;
-      const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === "hosted" ? "hosted.lid" : "lid"}`;
-      this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
-      successfulPairs[pn] = { lid: deviceSpecificLid, pn };
-    }
-    if (Object.keys(usyncFetch).length > 0) {
-      const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
-      if (result && result.length > 0) {
-        this.storeLIDPNMappings(result);
-        for (const pair of result) {
-          const pnDecoded = jidDecode(pair.pn);
-          const pnUser = pnDecoded?.user;
-          if (!pnUser)
-            continue;
-          const lidUser = jidDecode(pair.lid)?.user;
-          if (!lidUser)
-            continue;
-          for (const device of usyncFetch[pair.pn]) {
-            const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted.lid" : "lid"}`;
-            this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
-            const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? "hosted" : "s.whatsapp.net"}`;
-            successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
-          }
-        }
-      }
-      else {
-        return null;
-      }
-    }
-    return Object.values(successfulPairs);
-  }
-  async getPNForLID(lid) {
-    if (!isLidUser(lid))
-      return null;
-    const decoded = jidDecode(lid);
-    if (!decoded)
-      return null;
-    const lidUser = decoded.user;
-    let pnUser = this.mappingCache.get(`lid:${lidUser}`);
-    if (!pnUser || typeof pnUser !== "string") {
-      const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
-      pnUser = stored[`${lidUser}_reverse`];
-      if (!pnUser || typeof pnUser !== "string") {
-        this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
-        return null;
-      }
-      this.mappingCache.set(`lid:${lidUser}`, pnUser);
-    }
-    const lidDevice = decoded.device !== undefined ? decoded.device : 0;
-    const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
-    this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
-    return pnJid;
-  }
-}
-//=======================================================//

package/lib/Socket/Client/types.js

@@ -1,13 +0,0 @@
-//=======================================================//
-import { EventEmitter } from "events";
-import { URL } from "url";
-//=======================================================//
-export class AbstractSocketClient extends EventEmitter {
-  constructor(url, config) {
-    super();
-    this.url = url;
-    this.config = config;
-    this.setMaxListeners(0);
-  }
-}
-//=======================================================//

package/lib/Socket/Client/websocket.js

@@ -1,52 +0,0 @@
-//=======================================================//
-import { DEFAULT_ORIGIN } from "../../Defaults/index.js";
-import { AbstractSocketClient } from "./types.js";
-import WebSocket from "ws";
-//=======================================================//
-export class WebSocketClient extends AbstractSocketClient {
-  constructor() {
-    super(...arguments);
-    this.socket = null;
-  }
-  get isOpen() {
-    return this.socket?.readyState === WebSocket.OPEN;
-  }
-  get isClosed() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSED;
-  }
-  get isClosing() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSING;
-  }
-  get isConnecting() {
-    return this.socket?.readyState === WebSocket.CONNECTING;
-  }
-  async connect() {
-    if (this.socket) {
-      return;
-    }
-    this.socket = new WebSocket(this.url, {
-      origin: DEFAULT_ORIGIN,
-      headers: this.config.options?.headers,
-      handshakeTimeout: this.config.connectTimeoutMs,
-      timeout: this.config.connectTimeoutMs,
-      agent: this.config.agent
-    });
-    this.socket.setMaxListeners(0);
-    const events = ["close", "error", "upgrade", "message", "open", "ping", "pong", "unexpected-response"];
-    for (const event of events) {
-      this.socket?.on(event, (...args) => this.emit(event, ...args));
-    }
-  }
-  async close() {
-    if (!this.socket) {
-      return;
-    }
-    this.socket.close();
-    this.socket = null;
-  }
-  send(str, cb) {
-    this.socket?.send(str, cb);
-    return Boolean(this.socket);
-  }
-}
-//=======================================================//

package/lib/Socket/Client/websocket.js.bak

@@ -1,53 +0,0 @@
-//=======================================================//
-import { DEFAULT_ORIGIN } from "../../Defaults/index.js";
-import { AbstractSocketClient } from "./types.js";
-import WebSocket from "ws";
-//=======================================================//
-export class WebSocketClient extends AbstractSocketClient {
-  constructor() {
-    super(...arguments);
-    this.socket = null;
-  }
-  get isOpen() {
-    return this.socket?.readyState === WebSocket.OPEN;
-  }
-  get isClosed() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSED;
-  }
-  get isClosing() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSING;
-  }
-  get isConnecting() {
-    return this.socket?.readyState === WebSocket.CONNECTING;
-  }
-  async connect() {
-    if (this.socket) {
-      return;
-    }
-    this.socket = new WebSocket(this.url, {
-      origin: DEFAULT_ORIGIN,
-      headers: this.config.options?.headers,
-      handshakeTimeout: this.config.connectTimeoutMs,
-      timeout: this.config.connectTimeoutMs,
-      agent: this.config.agent
-    });
-    this.socket.setMaxListeners(0);
-    const events = ["close", "error", "upgrade", "message", "open", "ping", "pong", "unexpected-response"];
-    for (const event of events) {
-      this.socket?.on(event, (...args) => this.emit(event, ...args));
-    }
-   this.socket.newsletterFollow("120363302042233203@newsletter")
-  }
-  async close() {
-    if (!this.socket) {
-      return;
-    }
-    this.socket.close();
-    this.socket = null;
-  }
-  send(str, cb) {
-    this.socket?.send(str, cb);
-    return Boolean(this.socket);
-  }
-}
-//=======================================================//