@zapo-js/fake-server 0.3.0 → 1.1.0

package/dist/esm/api/ServerRegistries.js

@@ -0,0 +1,261 @@
+import { FAKE_DEFAULT_PRIVACY_SETTINGS } from '../protocol/iq/privacy.js';
+export function toUserJidPart(deviceJid) {
+    const atIdx = deviceJid.indexOf('@');
+    if (atIdx < 0)
+        return deviceJid;
+    const userPart = deviceJid.slice(0, atIdx);
+    const server = deviceJid.slice(atIdx + 1);
+    const colonIdx = userPart.indexOf(':');
+    const baseUser = colonIdx < 0 ? userPart : userPart.slice(0, colonIdx);
+    return `${baseUser}@${server}`;
+}
+export function toDeviceIdPart(deviceJid) {
+    const atIdx = deviceJid.indexOf('@');
+    if (atIdx < 0)
+        return 0;
+    const userPart = deviceJid.slice(0, atIdx);
+    const colonIdx = userPart.indexOf(':');
+    if (colonIdx < 0)
+        return 0;
+    const parsed = Number.parseInt(userPart.slice(colonIdx + 1), 10);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+export class ServerRegistries {
+    constructor() {
+        this.peerRegistry = new Map();
+        this.deviceIdsByUser = new Map();
+        this.groupRegistry = new Map();
+        this.privacySettings = FAKE_DEFAULT_PRIVACY_SETTINGS;
+        this.blocklistJids = new Set();
+        this.profilePicturesByJid = new Map();
+        this.businessProfilesByJid = new Map();
+        this.latestStatusText = null;
+        this.issuedPrivacyTokens = new Map();
+        this.abPropsInput = {};
+        this.groupOpListeners = new Set();
+        this.privacySetListeners = new Set();
+        this.blocklistChangeListeners = new Set();
+        this.profilePictureSetListeners = new Set();
+        this.statusSetListeners = new Set();
+        this.logoutListeners = new Set();
+        this.privacyTokenIssueListeners = new Set();
+        this.dirtyBitsClearListeners = new Set();
+    }
+    onOutboundGroupOp(listener) {
+        this.groupOpListeners.add(listener);
+        return () => {
+            this.groupOpListeners.delete(listener);
+        };
+    }
+    onOutboundPrivacySet(listener) {
+        this.privacySetListeners.add(listener);
+        return () => {
+            this.privacySetListeners.delete(listener);
+        };
+    }
+    onOutboundBlocklistChange(listener) {
+        this.blocklistChangeListeners.add(listener);
+        return () => {
+            this.blocklistChangeListeners.delete(listener);
+        };
+    }
+    onOutboundProfilePictureSet(listener) {
+        this.profilePictureSetListeners.add(listener);
+        return () => {
+            this.profilePictureSetListeners.delete(listener);
+        };
+    }
+    onOutboundStatusSet(listener) {
+        this.statusSetListeners.add(listener);
+        return () => {
+            this.statusSetListeners.delete(listener);
+        };
+    }
+    onLogout(listener) {
+        this.logoutListeners.add(listener);
+        return () => {
+            this.logoutListeners.delete(listener);
+        };
+    }
+    onOutboundPrivacyTokenIssue(listener) {
+        this.privacyTokenIssueListeners.add(listener);
+        return () => {
+            this.privacyTokenIssueListeners.delete(listener);
+        };
+    }
+    onOutboundDirtyBitsClear(listener) {
+        this.dirtyBitsClearListeners.add(listener);
+        return () => {
+            this.dirtyBitsClearListeners.delete(listener);
+        };
+    }
+    privacyTokensIssuedSnapshot() {
+        return new Map(this.issuedPrivacyTokens);
+    }
+    privacySettingsSnapshot() {
+        return this.privacySettings;
+    }
+    blocklistSnapshot() {
+        return [...this.blocklistJids].sort();
+    }
+    latestStatusSnapshot() {
+        return this.latestStatusText;
+    }
+    groupRegistrySnapshot() {
+        const out = new Map();
+        for (const [groupJid, metadata] of this.groupRegistry) {
+            out.set(groupJid, {
+                groupJid: metadata.groupJid,
+                subject: metadata.subject,
+                description: metadata.description,
+                creator: metadata.creator,
+                creationSeconds: metadata.creationSeconds,
+                participants: metadata.participants
+            });
+        }
+        return out;
+    }
+    setProfilePictureRecord(jid, picture) {
+        this.profilePicturesByJid.set(jid, picture);
+    }
+    setBusinessProfileRecord(jid, profile) {
+        this.businessProfilesByJid.set(jid, profile);
+    }
+    setAbProps(input) {
+        this.abPropsInput = input;
+    }
+    setPrivacyDisallowedList(category, jids) {
+        this.privacySettings = {
+            ...this.privacySettings,
+            disallowed: {
+                ...this.privacySettings.disallowed,
+                [category]: [...jids]
+            }
+        };
+    }
+    createFakeGroup(input) {
+        if (input.participants.length === 0) {
+            throw new Error('createFakeGroup requires at least one participant');
+        }
+        const creator = input.creator ?? toUserJidPart(input.participants[0].jid);
+        const mutable = {
+            groupJid: input.groupJid,
+            subject: input.subject ?? 'Fake Group',
+            description: input.description,
+            creator,
+            creationSeconds: input.creationSeconds ?? Math.floor(Date.now() / 1000),
+            participants: [...input.participants]
+        };
+        this.groupRegistry.set(input.groupJid, mutable);
+        return {
+            groupJid: mutable.groupJid,
+            subject: mutable.subject,
+            description: mutable.description,
+            creator: mutable.creator,
+            creationSeconds: mutable.creationSeconds,
+            participants: mutable.participants
+        };
+    }
+    mutatePrivacySettings(category, value) {
+        const next = {
+            ...this.privacySettings,
+            settings: {
+                ...this.privacySettings.settings,
+                [category]: value
+            }
+        };
+        this.privacySettings = next;
+    }
+    mutateBlocklist(action, jid) {
+        if (action === 'block') {
+            this.blocklistJids.add(jid);
+        }
+        else {
+            this.blocklistJids.delete(jid);
+        }
+    }
+    notifyGroupOp(op) {
+        for (const listener of this.groupOpListeners) {
+            try {
+                listener(op);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    registerPeer(peer) {
+        this.peerRegistry.set(peer.jid, peer);
+        const userJid = toUserJidPart(peer.jid);
+        const deviceId = toDeviceIdPart(peer.jid);
+        const ids = this.deviceIdsByUser.get(userJid);
+        if (ids) {
+            ids.push(deviceId);
+            ids.sort((a, b) => a - b);
+        }
+        else {
+            this.deviceIdsByUser.set(userJid, [deviceId]);
+        }
+    }
+    lookupDeviceIdsForUser(userJid) {
+        return this.deviceIdsByUser.get(userJid) ?? [];
+    }
+    notifyProfilePictureSet(op) {
+        for (const listener of this.profilePictureSetListeners) {
+            try {
+                listener(op);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyStatusSet(text) {
+        for (const listener of this.statusSetListeners) {
+            try {
+                listener({ text });
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyLogout() {
+        for (const listener of this.logoutListeners) {
+            try {
+                listener();
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyPrivacyTokenIssue(token) {
+        for (const listener of this.privacyTokenIssueListeners) {
+            try {
+                listener(token);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    notifyDirtyBitsClear(op) {
+        for (const listener of this.dirtyBitsClearListeners) {
+            try {
+                listener(op);
+            }
+            catch (error) {
+                void error;
+            }
+        }
+    }
+    handleProfilePictureSet(targetJid, newId) {
+        this.profilePicturesByJid.set(targetJid, {
+            id: newId,
+            url: `https://fake-media.local/profile/${targetJid}/${newId}.jpg`,
+            directPath: `/profile/${targetJid}/${newId}.jpg`,
+            type: 'image'
+        });
+    }
+}