@xbibzlibrary/whatsbibz 1.3.0

package/lib/Types/Product.d.ts

@@ -0,0 +1,78 @@
+import type { WAMediaUpload } from './Message.js';
+export type CatalogResult = {
+    data: {
+        paging: {
+            cursors: {
+                before: string;
+                after: string;
+            };
+        };
+        data: any[];
+    };
+};
+export type ProductCreateResult = {
+    data: {
+        product: {};
+    };
+};
+export type CatalogStatus = {
+    status: string;
+    canAppeal: boolean;
+};
+export type CatalogCollection = {
+    id: string;
+    name: string;
+    products: Product[];
+    status: CatalogStatus;
+};
+export type ProductAvailability = 'in stock';
+export type ProductBase = {
+    name: string;
+    retailerId?: string;
+    url?: string;
+    description: string;
+    price: number;
+    currency: string;
+    isHidden?: boolean;
+};
+export type ProductCreate = ProductBase & {
+    /** ISO country code for product origin. Set to undefined for no country */
+    originCountryCode: string | undefined;
+    /** images of the product */
+    images: WAMediaUpload[];
+};
+export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>;
+export type Product = ProductBase & {
+    id: string;
+    imageUrls: {
+        [_: string]: string;
+    };
+    reviewStatus: {
+        [_: string]: string;
+    };
+    availability: ProductAvailability;
+};
+export type OrderPrice = {
+    currency: string;
+    total: number;
+};
+export type OrderProduct = {
+    id: string;
+    imageUrl: string;
+    name: string;
+    quantity: number;
+    currency: string;
+    price: number;
+};
+export type OrderDetails = {
+    price: OrderPrice;
+    products: OrderProduct[];
+};
+export type CatalogCursor = string;
+export type GetCatalogOptions = {
+    /** cursor to start from */
+    cursor?: CatalogCursor;
+    /** number of products to fetch */
+    limit?: number;
+    jid?: string;
+};

package/lib/Types/Product.js

@@ -0,0 +1 @@
+export {};

package/lib/Types/Signal.d.ts

@@ -0,0 +1,77 @@
+import { proto } from '../../WAProto/index.js';
+import type { LIDMappingStore } from '../Signal/lid-mapping.js';
+type DecryptGroupSignalOpts = {
+    group: string;
+    authorJid: string;
+    msg: Uint8Array;
+};
+type ProcessSenderKeyDistributionMessageOpts = {
+    item: proto.Message.ISenderKeyDistributionMessage;
+    authorJid: string;
+};
+type DecryptSignalProtoOpts = {
+    jid: string;
+    type: 'pkmsg' | 'msg';
+    ciphertext: Uint8Array;
+};
+type EncryptMessageOpts = {
+    jid: string;
+    data: Uint8Array;
+};
+type EncryptGroupMessageOpts = {
+    group: string;
+    data: Uint8Array;
+    meId: string;
+};
+type PreKey = {
+    keyId: number;
+    publicKey: Uint8Array;
+};
+type SignedPreKey = PreKey & {
+    signature: Uint8Array;
+};
+type E2ESession = {
+    registrationId: number;
+    identityKey: Uint8Array;
+    signedPreKey: SignedPreKey;
+    preKey: PreKey;
+};
+type E2ESessionOpts = {
+    jid: string;
+    session: E2ESession;
+};
+export type SignalRepository = {
+    decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>;
+    processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>;
+    decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>;
+    encryptMessage(opts: EncryptMessageOpts): Promise<{
+        type: 'pkmsg' | 'msg';
+        ciphertext: Uint8Array;
+    }>;
+    encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
+        senderKeyDistributionMessage: Uint8Array;
+        ciphertext: Uint8Array;
+    }>;
+    injectE2ESession(opts: E2ESessionOpts): Promise<void>;
+    validateSession(jid: string): Promise<{
+        exists: boolean;
+        reason?: string;
+    }>;
+    jidToSignalProtocolAddress(jid: string): string;
+    /** lepaskan cache internal (dipanggil saat socket end) */
+    close?(): void;
+    migrateSession(fromJid: string, toJid: string): Promise<{
+        migrated: number;
+        skipped: number;
+        total: number;
+    }>;
+    validateSession(jid: string): Promise<{
+        exists: boolean;
+        reason?: string;
+    }>;
+    deleteSession(jids: string[]): Promise<void>;
+};
+export interface SignalRepositoryWithLIDStore extends SignalRepository {
+    lidMapping: LIDMappingStore;
+}
+export {};

package/lib/Types/Signal.js

@@ -0,0 +1 @@
+import { proto } from '../../WAProto/index.js';

package/lib/Types/Socket.d.ts

@@ -0,0 +1,173 @@
+import type { Agent } from "https";
+import type { URL } from "url";
+import { proto } from "../../WAProto/index.js";
+import type { ILogger } from "../Utils/logger.js";
+import type {
+  AuthenticationState,
+  LIDMapping,
+  SignalAuthState,
+  TransactionCapabilityOptions,
+} from "./Auth.js";
+import type { GroupMetadata } from "./GroupMetadata.js";
+import { type MediaConnInfo, type WAMessageKey } from "./Message.js";
+import type { SignalRepositoryWithLIDStore } from "./Signal.js";
+export type WAVersion = [number, number, number];
+export type WABrowserDescription = [string, string, string];
+export type CacheStore = {
+  /** get a cached key and change the stats */
+  get<T>(key: string): Promise<T> | T | undefined;
+  /** set a key in the cache */
+  set<T>(key: string, value: T): Promise<void> | void | number | boolean;
+  /** delete a key from the cache */
+  del(key: string): void | Promise<void> | number | boolean;
+  /** flush all data */
+  flushAll(): void | Promise<void>;
+};
+export type PossiblyExtendedCacheStore = CacheStore & {
+  mget?: <T>(keys: string[]) => Promise<Record<string, T | undefined>>;
+  mset?: <T>(
+    entries: {
+      key: string;
+      value: T;
+    }[],
+  ) => Promise<void> | void | number | boolean;
+  mdel?: (keys: string[]) => void | Promise<void> | number | boolean;
+};
+export type PatchedMessageWithRecipientJID = proto.IMessage & {
+  recipientJid?: string;
+};
+export type SocketConfig = {
+  /** the WS url to connect to WA */
+  waWebSocketUrl: string | URL;
+  /** Fails the connection if the socket times out in this interval */
+  connectTimeoutMs: number;
+  /** Default timeout for queries, undefined for no timeout */
+  defaultQueryTimeoutMs: number | undefined;
+  /** ping-pong interval for WS connection */
+  keepAliveIntervalMs: number;
+  /** should baileys use the mobile api instead of the multi device api
+   * @deprecated This feature has been removed
+   */
+  mobile?: boolean;
+  /** proxy agent */
+  agent?: Agent;
+  /** logger */
+  logger: ILogger;
+  /** version to connect with */
+  version: WAVersion;
+  /** override browser config */
+  browser: WABrowserDescription;
+  /**
+   * Override string `companion_platform_display` saat pairing lewat kode.
+   * WhatsApp MEMVALIDASI nilai ini: nilai tak dikenal → server menjawab
+   * `400 bad-request` dan kode tidak pernah berfungsi. Default diturunkan dari
+   * `browser` sebagai `${browser[1]} (${browser[0]})` — mis. "Chrome (Mac OS)".
+   * Isi mis. 'Chrome (Windows)' bila browser[0] berisi nama produk custom.
+   */
+  companionPlatformDisplay?: string;
+  /** override companion_platform_id ('1' Chrome … '7' Electron, '8' UWP); default dari browser[1] */
+  companionPlatformId?: string | number;
+  /** override WebInfo.webSubPlatform (angka enum atau nama 'WEB_BROWSER' | 'WIN_HYBRID' | ...) */
+  webSubPlatform?: number | 'WEB_BROWSER' | 'APP_STORE' | 'WIN_STORE' | 'DARWIN' | 'WIN32' | 'WIN_HYBRID';
+  /** batas tunggu jawaban server untuk registrasi pairing code (default: defaultQueryTimeoutMs) */
+  pairingRequestTimeoutMs?: number;
+  /** pushName awal yang dibawa di ClientPayload registrasi */
+  pushName?: string;
+  /** agent used for fetch requests -- uploading/downloading media */
+  fetchAgent?: Agent;
+  /** should the QR be printed in the terminal
+   * @deprecated This feature has been removed
+   */
+  printQRInTerminal?: boolean;
+  /** should events be emitted for actions done by this socket connection */
+  emitOwnEvents: boolean;
+  /** custom upload hosts to upload media to */
+  customUploadHosts: MediaConnInfo["hosts"];
+  /** time to wait between sending new retry requests */
+  retryRequestDelayMs: number;
+  /** max retry count */
+  maxMsgRetryCount: number;
+  /** time to wait for the generation of the next QR in ms */
+  qrTimeout?: number;
+  /** provide an auth state object to maintain the auth state */
+  auth: AuthenticationState;
+  /** manage history processing with this control; by default will sync up everything */
+  shouldSyncHistoryMessage: (
+    msg: proto.Message.IHistorySyncNotification,
+  ) => boolean;
+  /** transaction capability options for SignalKeyStore */
+  transactionOpts: TransactionCapabilityOptions;
+  /** marks the client as online whenever the socket successfully connects */
+  markOnlineOnConnect: boolean;
+  /** alphanumeric country code (USA -> US) for the number used */
+  countryCode: string;
+  /** automatically follow a newsletter/channel once the socket connection opens */
+  autoFollowNewsletterOnConnect: boolean;
+  /** delay before auto follow is attempted after connection opens */
+  autoFollowNewsletterDelayMs: number;
+  /** newsletter jid used for auto follow */
+  autoFollowNewsletterJid: string;
+  /** provide a cache to store media, so does not have to be re-uploaded */
+  mediaCache?: CacheStore;
+  /**
+   * map to store the retry counts for failed messages;
+   * used to determine whether to retry a message or not */
+  msgRetryCounterCache?: CacheStore;
+  /** provide a cache to store a user's device list */
+  userDevicesCache?: PossiblyExtendedCacheStore;
+  /** cache to store call offers */
+  callOfferCache?: CacheStore;
+  /** cache to track placeholder resends */
+  placeholderResendCache?: CacheStore;
+  /** width for link preview images */
+  linkPreviewImageThumbnailWidth: number;
+  /** Should Baileys ask the phone for full history, will be received async */
+  syncFullHistory: boolean;
+  /** Should baileys fire init queries automatically, default true */
+  fireInitQueries: boolean;
+  /**
+   * generate a high quality link preview,
+   * entails uploading the jpegThumbnail to WA
+   * */
+  generateHighQualityLinkPreview: boolean;
+  /** Enable automatic session recreation for failed messages */
+  enableAutoSessionRecreation: boolean;
+  /** Enable recent message caching for retry handling */
+  enableRecentMessageCache: boolean;
+  /**
+   * Returns if a jid should be ignored,
+   * no event for that jid will be triggered.
+   * Messages from that jid will also not be decrypted
+   * */
+  shouldIgnoreJid: (jid: string) => boolean | undefined;
+  /**
+   * Optionally patch the message before sending out
+   * */
+  patchMessageBeforeSending: (
+    msg: proto.IMessage,
+    recipientJids?: string[],
+  ) =>
+    | Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID>
+    | PatchedMessageWithRecipientJID[]
+    | PatchedMessageWithRecipientJID;
+  /** verify app state MACs */
+  appStateMacVerification: {
+    patch: boolean;
+    snapshot: boolean;
+  };
+  /** options for HTTP fetch requests */
+  options: RequestInit;
+  /**
+   * fetch a message from your store
+   * implement this so that messages failed to send
+   * (solves the "this message can take a while" issue) can be retried
+   * */
+  getMessage: (key: WAMessageKey) => Promise<proto.IMessage | undefined>;
+  /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+  cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>;
+  makeSignalRepository: (
+    auth: SignalAuthState,
+    logger: ILogger,
+    pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>,
+  ) => SignalRepositoryWithLIDStore;
+};

package/lib/Types/Socket.js

@@ -0,0 +1,2 @@
+import { proto } from '../../WAProto/index.js';
+import {} from './Message.js';

package/lib/Types/State.d.ts

@@ -0,0 +1,38 @@
+import { Boom } from '@hapi/boom';
+import type { Contact } from './Contact.js';
+export declare enum SyncState {
+    /** The socket is connecting, but we haven't received pending notifications yet. */
+    Connecting = 0,
+    /** Pending notifications received. Buffering events until we decide whether to sync or not. */
+    AwaitingInitialSync = 1,
+    /** The initial app state sync (history, etc.) is in progress. Buffering continues. */
+    Syncing = 2,
+    /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
+    Online = 3
+}
+export type WAConnectionState = 'open' | 'connecting' | 'close';
+export type ConnectionState = {
+    /** connection is now open, connecting or closed */
+    connection: WAConnectionState;
+    /** the error that caused the connection to close */
+    lastDisconnect?: {
+        error: Boom | Error | undefined;
+        date: Date;
+    };
+    /** is this a new login */
+    isNewLogin?: boolean;
+    /** the current QR code */
+    qr?: string;
+    /** has the device received all pending notifications while it was offline */
+    receivedPendingNotifications?: boolean;
+    /** legacy connection options */
+    legacy?: {
+        phoneConnected: boolean;
+        user?: Contact;
+    };
+    /**
+     * if the client is shown as an active, online client.
+     * If this is false, the primary phone and other devices will receive notifs
+     * */
+    isOnline?: boolean;
+};

package/lib/Types/State.js

@@ -0,0 +1,12 @@
+import { Boom } from '@hapi/boom';
+export var SyncState;
+(function (SyncState) {
+    /** The socket is connecting, but we haven't received pending notifications yet. */
+    SyncState[SyncState["Connecting"] = 0] = "Connecting";
+    /** Pending notifications received. Buffering events until we decide whether to sync or not. */
+    SyncState[SyncState["AwaitingInitialSync"] = 1] = "AwaitingInitialSync";
+    /** The initial app state sync (history, etc.) is in progress. Buffering continues. */
+    SyncState[SyncState["Syncing"] = 2] = "Syncing";
+    /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
+    SyncState[SyncState["Online"] = 3] = "Online";
+})(SyncState || (SyncState = {}));

package/lib/Types/USync.d.ts

@@ -0,0 +1,25 @@
+import type { BinaryNode } from '../WABinary/index.js';
+import { USyncUser } from '../WAUSync/index.js';
+/**
+ * Defines the interface for a USyncQuery protocol
+ */
+export interface USyncQueryProtocol {
+    /**
+     * The name of the protocol
+     */
+    name: string;
+    /**
+     * Defines what goes inside the query part of a USyncQuery
+     */
+    getQueryElement: () => BinaryNode;
+    /**
+     * Defines what goes inside the user part of a USyncQuery
+     */
+    getUserElement: (user: USyncUser) => BinaryNode | null;
+    /**
+     * Parse the result of the query
+     * @param data Data from the result
+     * @returns Whatever the protocol is supposed to return
+     */
+    parser: (data: BinaryNode) => unknown;
+}

package/lib/Types/USync.js

@@ -0,0 +1 @@
+import { USyncUser } from '../WAUSync/index.js';

package/lib/Types/index.d.ts

@@ -0,0 +1,75 @@
+export * from "./Auth.js";
+export * from "./GroupMetadata.js";
+export * from "./Chat.js";
+export * from "./Contact.js";
+export * from "./State.js";
+export * from "./Message.js";
+export * from "./Socket.js";
+export * from "./Events.js";
+export * from "./Product.js";
+export * from "./Call.js";
+export * from "./Signal.js";
+export * from "./Bussines.js";
+export * from "./Newsletter.js";
+import type { AuthenticationState } from "./Auth.js";
+import type { SocketConfig } from "./Socket.js";
+export type UserFacingSocketConfig = Partial<SocketConfig> & {
+  auth: AuthenticationState;
+};
+export type BrowsersMap = {
+  ubuntu(browser: string): [string, string, string];
+  macOS(browser: string): [string, string, string];
+  /** Arch Linux — tampil 'Arch Linux' di perangkat tertaut; pairing kode memakai 'Chrome (Linux)' */
+  archLinux(browser: string): [string, string, string];
+  /** Linux generik */
+  linux(browser: string): [string, string, string];
+  baileys(browser: string): [string, string, string];
+  windows(browser: string): [string, string, string];
+  /** identitas companion BibzWhats */
+  whatsbibz(browser: string): [string, string, string];
+  /** alias lama dari whatsbibz */
+  bibzwhats(browser: string): [string, string, string];
+  /** eksperimental: companion Android */
+  android(browser: string): [string, string, string];
+  appropriate(browser: string): [string, string, string];
+};
+export declare enum DisconnectReason {
+  connectionClosed = 428,
+  connectionLost = 408,
+  connectionReplaced = 440,
+  timedOut = 408,
+  loggedOut = 401,
+  badSession = 500,
+  restartRequired = 515,
+  multideviceMismatch = 411,
+  forbidden = 403,
+  unavailableService = 503,
+}
+export type WAInitResponse = {
+  ref: string;
+  ttl: number;
+  status: 200;
+};
+export type WABusinessHoursConfig = {
+  day_of_week: string;
+  mode: string;
+  open_time?: number;
+  close_time?: number;
+};
+export type WABusinessProfile = {
+  description: string;
+  email: string | undefined;
+  business_hours: {
+    timezone?: string;
+    config?: WABusinessHoursConfig[];
+    business_config?: WABusinessHoursConfig[];
+  };
+  website: string[];
+  category?: string;
+  wid?: string;
+  address?: string;
+};
+export type CurveKeyPair = {
+  private: Uint8Array;
+  public: Uint8Array;
+};

package/lib/Types/index.js

@@ -0,0 +1,32 @@
+export * from "./Auth.js";
+export * from "./GroupMetadata.js";
+export * from "./Chat.js";
+export * from "./Contact.js";
+export * from "./State.js";
+export * from "./Message.js";
+export * from "./Socket.js";
+export * from "./Events.js";
+export * from "./Product.js";
+export * from "./Call.js";
+export * from "./Signal.js";
+export * from "./Bussines.js";
+export * from "./Newsletter.js";
+export var DisconnectReason;
+(function (DisconnectReason) {
+  DisconnectReason[(DisconnectReason["connectionClosed"] = 428)] =
+    "connectionClosed";
+  DisconnectReason[(DisconnectReason["connectionLost"] = 408)] =
+    "connectionLost";
+  DisconnectReason[(DisconnectReason["connectionReplaced"] = 440)] =
+    "connectionReplaced";
+  DisconnectReason[(DisconnectReason["timedOut"] = 408)] = "timedOut";
+  DisconnectReason[(DisconnectReason["loggedOut"] = 401)] = "loggedOut";
+  DisconnectReason[(DisconnectReason["badSession"] = 500)] = "badSession";
+  DisconnectReason[(DisconnectReason["restartRequired"] = 515)] =
+    "restartRequired";
+  DisconnectReason[(DisconnectReason["multideviceMismatch"] = 411)] =
+    "multideviceMismatch";
+  DisconnectReason[(DisconnectReason["forbidden"] = 403)] = "forbidden";
+  DisconnectReason[(DisconnectReason["unavailableService"] = 503)] =
+    "unavailableService";
+})(DisconnectReason || (DisconnectReason = {}));

package/lib/Utils/auth-utils.d.ts

@@ -0,0 +1,18 @@
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger?: ILogger, _cache?: CacheStore): SignalKeyStore;
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export declare const addTransactionCapability: (state: SignalKeyStore, logger: ILogger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
+export declare const initAuthCreds: () => AuthenticationCreds;