@tagea/capacitor-matrix 0.0.2

package/dist/plugin.js

@@ -0,0 +1,964 @@
+var capacitorCapMatrix = (function (exports, core, matrixJsSdk, recoveryKey, keyPassphrase) {
+    'use strict';
+
+    const Matrix = core.registerPlugin('Matrix', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.MatrixWeb()),
+    });
+
+    const SESSION_KEY = 'matrix_session';
+    class MatrixWeb extends core.WebPlugin {
+        constructor() {
+            super(...arguments);
+            this._cryptoCallbacks = {
+                getSecretStorageKey: async (opts) => {
+                    var _a;
+                    const keyId = Object.keys(opts.keys)[0];
+                    if (!keyId)
+                        return null;
+                    // If we have the raw key cached, use it directly
+                    if (this.secretStorageKey) {
+                        return [keyId, this.secretStorageKey];
+                    }
+                    // If we have a passphrase, derive the key using the server's stored parameters
+                    if (this.recoveryPassphrase) {
+                        const keyInfo = opts.keys[keyId];
+                        if (keyInfo === null || keyInfo === void 0 ? void 0 : keyInfo.passphrase) {
+                            const derived = await keyPassphrase.deriveRecoveryKeyFromPassphrase(this.recoveryPassphrase, keyInfo.passphrase.salt, keyInfo.passphrase.iterations, (_a = keyInfo.passphrase.bits) !== null && _a !== void 0 ? _a : 256);
+                            this.secretStorageKey = derived;
+                            return [keyId, derived];
+                        }
+                    }
+                    return null;
+                },
+                cacheSecretStorageKey: (_keyId, _keyInfo, key) => {
+                    this.secretStorageKey = key;
+                },
+            };
+        }
+        // ── Auth ──────────────────────────────────────────────
+        async login(options) {
+            const tmpClient = matrixJsSdk.createClient({ baseUrl: options.homeserverUrl });
+            const res = await tmpClient.loginWithPassword(options.userId, options.password);
+            this.client = matrixJsSdk.createClient({
+                baseUrl: options.homeserverUrl,
+                accessToken: res.access_token,
+                userId: res.user_id,
+                deviceId: res.device_id,
+                cryptoCallbacks: this._cryptoCallbacks,
+            });
+            const session = {
+                accessToken: res.access_token,
+                userId: res.user_id,
+                deviceId: res.device_id,
+                homeserverUrl: options.homeserverUrl,
+            };
+            this.persistSession(session);
+            return session;
+        }
+        async loginWithToken(options) {
+            this.client = matrixJsSdk.createClient({
+                baseUrl: options.homeserverUrl,
+                accessToken: options.accessToken,
+                userId: options.userId,
+                deviceId: options.deviceId,
+                cryptoCallbacks: this._cryptoCallbacks,
+            });
+            const session = {
+                accessToken: options.accessToken,
+                userId: options.userId,
+                deviceId: options.deviceId,
+                homeserverUrl: options.homeserverUrl,
+            };
+            this.persistSession(session);
+            return session;
+        }
+        async logout() {
+            if (this.client) {
+                this.client.stopClient();
+                try {
+                    await this.client.logout(true);
+                }
+                catch (_a) {
+                    // ignore logout errors (e.g. token already invalidated)
+                }
+                this.client = undefined;
+            }
+            localStorage.removeItem(SESSION_KEY);
+        }
+        async getSession() {
+            const raw = localStorage.getItem(SESSION_KEY);
+            if (!raw)
+                return null;
+            try {
+                return JSON.parse(raw);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        // ── Sync ──────────────────────────────────────────────
+        async startSync() {
+            this.requireClient();
+            this.client.on(matrixJsSdk.ClientEvent.Sync, (state, _prev, data) => {
+                var _a;
+                const mapped = this.mapSyncState(state);
+                this.notifyListeners('syncStateChange', {
+                    state: mapped,
+                    error: (_a = data === null || data === void 0 ? void 0 : data.error) === null || _a === void 0 ? void 0 : _a.message,
+                });
+            });
+            this.client.on(matrixJsSdk.RoomEvent.Timeline, (event, room) => {
+                var _a;
+                this.notifyListeners('messageReceived', {
+                    event: this.serializeEvent(event, room === null || room === void 0 ? void 0 : room.roomId),
+                });
+                // When an encrypted event arrives, listen for decryption and re-notify
+                if (event.isBeingDecrypted() || event.getType() === 'm.room.encrypted') {
+                    event.once('Event.decrypted', () => {
+                        this.notifyListeners('messageReceived', {
+                            event: this.serializeEvent(event, room === null || room === void 0 ? void 0 : room.roomId),
+                        });
+                    });
+                }
+                // When a reaction or redaction arrives, re-emit the parent event with updated aggregated reactions
+                if (event.getType() === matrixJsSdk.EventType.Reaction || event.getType() === matrixJsSdk.EventType.RoomRedaction) {
+                    const rel = (_a = event.getContent()) === null || _a === void 0 ? void 0 : _a['m.relates_to'];
+                    const targetId = (rel === null || rel === void 0 ? void 0 : rel.event_id) || event.getAssociatedId();
+                    if (targetId && room) {
+                        const targetEvent = room.findEventById(targetId);
+                        if (targetEvent) {
+                            // Small delay to let the SDK finish aggregation
+                            setTimeout(() => {
+                                this.notifyListeners('messageReceived', {
+                                    event: this.serializeEvent(targetEvent, room.roomId),
+                                });
+                            }, 100);
+                        }
+                    }
+                }
+            });
+            this.client.on(matrixJsSdk.RoomEvent.Receipt, (_event, room) => {
+                var _a;
+                this.notifyListeners('receiptReceived', {
+                    roomId: room.roomId,
+                });
+                // Re-emit own sent messages with updated read status
+                const myUserId = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getUserId();
+                if (myUserId) {
+                    const timeline = room.getLiveTimeline().getEvents();
+                    // Walk backwards through recent events; stop after checking a reasonable batch
+                    const limit = Math.min(timeline.length, 50);
+                    for (let i = timeline.length - 1; i >= timeline.length - limit; i--) {
+                        const evt = timeline[i];
+                        if (evt.getSender() !== myUserId)
+                            continue;
+                        const serialized = this.serializeEvent(evt, room.roomId);
+                        if (serialized.status === 'read') {
+                            this.notifyListeners('messageReceived', { event: serialized });
+                        }
+                    }
+                }
+            });
+            this.client.on(matrixJsSdk.RoomEvent.Name, (room) => {
+                this.notifyListeners('roomUpdated', {
+                    roomId: room.roomId,
+                    summary: this.serializeRoom(room),
+                });
+            });
+            this.client.on(matrixJsSdk.RoomMemberEvent.Typing, (_event, member) => {
+                var _a, _b;
+                const roomId = member === null || member === void 0 ? void 0 : member.roomId;
+                if (roomId) {
+                    const room = this.client.getRoom(roomId);
+                    if (room) {
+                        const typingEvent = room.currentState.getStateEvents('m.typing', '');
+                        const userIds = (_b = (_a = typingEvent === null || typingEvent === void 0 ? void 0 : typingEvent.getContent()) === null || _a === void 0 ? void 0 : _a.user_ids) !== null && _b !== void 0 ? _b : [];
+                        this.notifyListeners('typingChanged', { roomId, userIds });
+                    }
+                }
+            });
+            this.client.on(matrixJsSdk.UserEvent.Presence, (_event, user) => {
+                var _a, _b, _c;
+                this.notifyListeners('presenceChanged', {
+                    userId: user.userId,
+                    presence: {
+                        presence: (_a = user.presence) !== null && _a !== void 0 ? _a : 'offline',
+                        statusMsg: (_b = user.presenceStatusMsg) !== null && _b !== void 0 ? _b : undefined,
+                        lastActiveAgo: (_c = user.lastActiveAgo) !== null && _c !== void 0 ? _c : undefined,
+                    },
+                });
+            });
+            await this.client.startClient({ initialSyncLimit: 20 });
+        }
+        async stopSync() {
+            this.requireClient();
+            this.client.stopClient();
+        }
+        async getSyncState() {
+            this.requireClient();
+            const raw = this.client.getSyncState();
+            return { state: this.mapSyncState(raw) };
+        }
+        // ── Rooms ─────────────────────────────────────────────
+        async createRoom(options) {
+            var _a;
+            this.requireClient();
+            const createOpts = {
+                visibility: 'private',
+            };
+            if (options.name)
+                createOpts.name = options.name;
+            if (options.topic)
+                createOpts.topic = options.topic;
+            if ((_a = options.invite) === null || _a === void 0 ? void 0 : _a.length)
+                createOpts.invite = options.invite;
+            if (options.preset)
+                createOpts.preset = options.preset;
+            if (options.isDirect)
+                createOpts.is_direct = true;
+            const initialState = [];
+            if (options.isEncrypted) {
+                initialState.push({
+                    type: 'm.room.encryption',
+                    state_key: '',
+                    content: { algorithm: 'm.megolm.v1.aes-sha2' },
+                });
+            }
+            if (options.historyVisibility) {
+                initialState.push({
+                    type: 'm.room.history_visibility',
+                    state_key: '',
+                    content: { history_visibility: options.historyVisibility },
+                });
+            }
+            if (initialState.length > 0) {
+                createOpts.initial_state = initialState;
+            }
+            const res = await this.client.createRoom(createOpts);
+            return { roomId: res.room_id };
+        }
+        async getRooms() {
+            this.requireClient();
+            const rooms = this.client.getRooms().map((r) => this.serializeRoom(r));
+            return { rooms };
+        }
+        async getRoomMembers(options) {
+            this.requireClient();
+            const room = this.client.getRoom(options.roomId);
+            if (!room)
+                throw new Error(`Room ${options.roomId} not found`);
+            await room.loadMembersIfNeeded();
+            const members = room.getMembers().map((m) => {
+                var _a, _b;
+                return ({
+                    userId: m.userId,
+                    displayName: (_a = m.name) !== null && _a !== void 0 ? _a : undefined,
+                    membership: m.membership,
+                    avatarUrl: (_b = m.getMxcAvatarUrl()) !== null && _b !== void 0 ? _b : undefined,
+                });
+            });
+            return { members };
+        }
+        async joinRoom(options) {
+            this.requireClient();
+            const room = await this.client.joinRoom(options.roomIdOrAlias);
+            return { roomId: room.roomId };
+        }
+        async leaveRoom(options) {
+            this.requireClient();
+            await this.client.leave(options.roomId);
+        }
+        async forgetRoom(options) {
+            this.requireClient();
+            await this.client.forget(options.roomId);
+        }
+        // ── Messaging ─────────────────────────────────────────
+        async sendMessage(options) {
+            var _a, _b, _c;
+            this.requireClient();
+            const msgtype = (_a = options.msgtype) !== null && _a !== void 0 ? _a : 'm.text';
+            const mediaTypes = ['m.image', 'm.audio', 'm.video', 'm.file'];
+            if (mediaTypes.includes(msgtype) && options.fileUri) {
+                // Media message: upload file then send
+                const response = await fetch(options.fileUri);
+                const blob = await response.blob();
+                const uploadRes = await this.client.uploadContent(blob, {
+                    name: options.fileName,
+                    type: options.mimeType,
+                });
+                const mxcUrl = uploadRes.content_uri;
+                const content = {
+                    msgtype,
+                    body: options.body || options.fileName || 'file',
+                    url: mxcUrl,
+                    info: {
+                        mimetype: options.mimeType,
+                        size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size,
+                    },
+                };
+                const res = await this.client.sendMessage(options.roomId, content);
+                return { eventId: res.event_id };
+            }
+            // Text message
+            const msgtypeMap = {
+                'm.text': matrixJsSdk.MsgType.Text,
+                'm.notice': matrixJsSdk.MsgType.Notice,
+                'm.emote': matrixJsSdk.MsgType.Emote,
+            };
+            const mappedType = (_c = msgtypeMap[msgtype]) !== null && _c !== void 0 ? _c : matrixJsSdk.MsgType.Text;
+            const res = await this.client.sendMessage(options.roomId, {
+                msgtype: mappedType,
+                body: options.body,
+            });
+            return { eventId: res.event_id };
+        }
+        async editMessage(options) {
+            this.requireClient();
+            const content = {
+                msgtype: matrixJsSdk.MsgType.Text,
+                body: `* ${options.newBody}`,
+                'm.new_content': {
+                    msgtype: matrixJsSdk.MsgType.Text,
+                    body: options.newBody,
+                },
+                'm.relates_to': {
+                    rel_type: 'm.replace',
+                    event_id: options.eventId,
+                },
+            };
+            const res = await this.client.sendMessage(options.roomId, content);
+            return { eventId: res.event_id };
+        }
+        async sendReply(options) {
+            var _a, _b;
+            this.requireClient();
+            const msgtype = (_a = options.msgtype) !== null && _a !== void 0 ? _a : 'm.text';
+            const mediaTypes = ['m.image', 'm.audio', 'm.video', 'm.file'];
+            let content;
+            if (mediaTypes.includes(msgtype) && options.fileUri) {
+                // Media reply: upload file then send with reply relation
+                const response = await fetch(options.fileUri);
+                const blob = await response.blob();
+                const uploadRes = await this.client.uploadContent(blob, {
+                    name: options.fileName,
+                    type: options.mimeType,
+                });
+                content = {
+                    msgtype,
+                    body: options.body || options.fileName || 'file',
+                    url: uploadRes.content_uri,
+                    info: {
+                        mimetype: options.mimeType,
+                        size: (_b = options.fileSize) !== null && _b !== void 0 ? _b : blob.size,
+                    },
+                    'm.relates_to': {
+                        'm.in_reply_to': {
+                            event_id: options.replyToEventId,
+                        },
+                    },
+                };
+            }
+            else {
+                // Text reply
+                content = {
+                    msgtype: matrixJsSdk.MsgType.Text,
+                    body: options.body,
+                    'm.relates_to': {
+                        'm.in_reply_to': {
+                            event_id: options.replyToEventId,
+                        },
+                    },
+                };
+            }
+            const res = await this.client.sendMessage(options.roomId, content);
+            return { eventId: res.event_id };
+        }
+        async getRoomMessages(options) {
+            var _a, _b, _c, _d, _e;
+            this.requireClient();
+            const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 20;
+            const room = this.client.getRoom(options.roomId);
+            // If no explicit pagination token, return events from the synced timeline
+            if (!options.from && room) {
+                // Paginate backwards so we have enough events (initial sync may be small)
+                try {
+                    await this.client.scrollback(room, limit);
+                }
+                catch (_f) {
+                    // scrollback may fail if there's no more history
+                }
+                const timeline = room.getLiveTimeline();
+                const timelineEvents = timeline.getEvents();
+                // Filter out reactions and redactions before slicing — they're aggregated into parent events
+                const displayableEvents = timelineEvents.filter((e) => {
+                    const t = e.getType();
+                    return t !== matrixJsSdk.EventType.Reaction && t !== matrixJsSdk.EventType.RoomRedaction;
+                });
+                const events = displayableEvents
+                    .slice(-limit)
+                    .map((e) => this.serializeEvent(e, options.roomId))
+                    .sort((a, b) => a.originServerTs - b.originServerTs);
+                const backToken = (_b = timeline.getPaginationToken(matrixJsSdk.Direction.Backward)) !== null && _b !== void 0 ? _b : undefined;
+                return { events, nextBatch: backToken };
+            }
+            // Paginate further back using the token
+            const fromToken = (_c = options.from) !== null && _c !== void 0 ? _c : null;
+            const res = await this.client.createMessagesRequest(options.roomId, fromToken, limit, matrixJsSdk.Direction.Backward);
+            const events = ((_d = res.chunk) !== null && _d !== void 0 ? _d : []).map((e) => {
+                var _a;
+                return ({
+                    eventId: e.event_id,
+                    roomId: options.roomId,
+                    senderId: e.sender,
+                    type: e.type,
+                    content: ((_a = e.content) !== null && _a !== void 0 ? _a : {}),
+                    originServerTs: e.origin_server_ts,
+                });
+            });
+            return { events, nextBatch: (_e = res.end) !== null && _e !== void 0 ? _e : undefined };
+        }
+        async markRoomAsRead(options) {
+            this.requireClient();
+            const room = this.client.getRoom(options.roomId);
+            if (room) {
+                const event = room.findEventById(options.eventId);
+                if (event) {
+                    await this.client.sendReadReceipt(event);
+                    return;
+                }
+            }
+            // Fallback to HTTP request if event not found locally
+            await this.client.setRoomReadMarkersHttpRequest(options.roomId, options.eventId, options.eventId);
+        }
+        async refreshEventStatuses(options) {
+            this.requireClient();
+            const room = this.client.getRoom(options.roomId);
+            if (!room)
+                return { events: [] };
+            const events = [];
+            for (const eid of options.eventIds) {
+                const event = room.findEventById(eid);
+                if (event) {
+                    events.push(this.serializeEvent(event, options.roomId));
+                }
+            }
+            return { events };
+        }
+        // ── Redactions & Reactions ───────────────────────────────
+        async redactEvent(options) {
+            this.requireClient();
+            await this.client.redactEvent(options.roomId, options.eventId, undefined, {
+                reason: options.reason,
+            });
+        }
+        async sendReaction(options) {
+            this.requireClient();
+            const myUserId = this.client.getUserId();
+            // Check if the user already reacted with this key — if so, toggle off (redact)
+            const room = this.client.getRoom(options.roomId);
+            if (room && myUserId) {
+                try {
+                    const relations = room.relations.getChildEventsForEvent(options.eventId, matrixJsSdk.RelationType.Annotation, matrixJsSdk.EventType.Reaction);
+                    if (relations) {
+                        const existing = relations.getRelations().find((e) => { var _a, _b; return e.getSender() === myUserId && ((_b = (_a = e.getContent()) === null || _a === void 0 ? void 0 : _a['m.relates_to']) === null || _b === void 0 ? void 0 : _b.key) === options.key; });
+                        if (existing) {
+                            const existingId = existing.getId();
+                            if (existingId) {
+                                await this.client.redactEvent(options.roomId, existingId);
+                                return { eventId: existingId };
+                            }
+                        }
+                    }
+                }
+                catch (_a) {
+                    // fall through to send
+                }
+            }
+            const res = await this.client.sendEvent(options.roomId, matrixJsSdk.EventType.Reaction, {
+                'm.relates_to': {
+                    rel_type: matrixJsSdk.RelationType.Annotation,
+                    event_id: options.eventId,
+                    key: options.key,
+                },
+            });
+            return { eventId: res.event_id };
+        }
+        // ── Room Management ────────────────────────────────────
+        async setRoomName(options) {
+            this.requireClient();
+            await this.client.setRoomName(options.roomId, options.name);
+        }
+        async setRoomTopic(options) {
+            this.requireClient();
+            await this.client.setRoomTopic(options.roomId, options.topic);
+        }
+        async setRoomAvatar(options) {
+            this.requireClient();
+            await this.client.sendStateEvent(options.roomId, 'm.room.avatar', { url: options.mxcUrl });
+        }
+        async inviteUser(options) {
+            this.requireClient();
+            await this.client.invite(options.roomId, options.userId);
+        }
+        async kickUser(options) {
+            this.requireClient();
+            await this.client.kick(options.roomId, options.userId, options.reason);
+        }
+        async banUser(options) {
+            this.requireClient();
+            await this.client.ban(options.roomId, options.userId, options.reason);
+        }
+        async unbanUser(options) {
+            this.requireClient();
+            await this.client.unban(options.roomId, options.userId);
+        }
+        // ── Typing ─────────────────────────────────────────────
+        async sendTyping(options) {
+            var _a;
+            this.requireClient();
+            await this.client.sendTyping(options.roomId, options.isTyping, (_a = options.timeout) !== null && _a !== void 0 ? _a : 30000);
+        }
+        // ── Media ──────────────────────────────────────────────
+        async getMediaUrl(options) {
+            this.requireClient();
+            // Use the authenticated media endpoint (Matrix v1.11+)
+            const mxcPath = options.mxcUrl.replace('mxc://', '');
+            const baseUrl = this.client.getHomeserverUrl().replace(/\/$/, '');
+            const accessToken = this.client.getAccessToken();
+            const httpUrl = `${baseUrl}/_matrix/client/v1/media/download/${mxcPath}?access_token=${accessToken}`;
+            return { httpUrl };
+        }
+        async getThumbnailUrl(options) {
+            var _a;
+            this.requireClient();
+            const mxcPath = options.mxcUrl.replace('mxc://', '');
+            const baseUrl = this.client.getHomeserverUrl().replace(/\/$/, '');
+            const accessToken = this.client.getAccessToken();
+            const method = (_a = options.method) !== null && _a !== void 0 ? _a : 'scale';
+            const httpUrl = `${baseUrl}/_matrix/client/v1/media/thumbnail/${mxcPath}?width=${options.width}&height=${options.height}&method=${method}&access_token=${accessToken}`;
+            return { httpUrl };
+        }
+        async uploadContent(options) {
+            this.requireClient();
+            const response = await fetch(options.fileUri);
+            const blob = await response.blob();
+            const res = await this.client.uploadContent(blob, {
+                name: options.fileName,
+                type: options.mimeType,
+            });
+            return { contentUri: res.content_uri };
+        }
+        // ── Presence ───────────────────────────────────────────
+        async setPresence(options) {
+            this.requireClient();
+            await this.client.setPresence({
+                presence: options.presence,
+                status_msg: options.statusMsg,
+            });
+        }
+        async getPresence(options) {
+            var _a, _b, _c;
+            this.requireClient();
+            const user = this.client.getUser(options.userId);
+            return {
+                presence: (_a = user === null || user === void 0 ? void 0 : user.presence) !== null && _a !== void 0 ? _a : 'offline',
+                statusMsg: (_b = user === null || user === void 0 ? void 0 : user.presenceStatusMsg) !== null && _b !== void 0 ? _b : undefined,
+                lastActiveAgo: (_c = user === null || user === void 0 ? void 0 : user.lastActiveAgo) !== null && _c !== void 0 ? _c : undefined,
+            };
+        }
+        // ── Device Management ──────────────────────────────────
+        async getDevices() {
+            var _a;
+            this.requireClient();
+            const res = await this.client.getDevices();
+            const devices = ((_a = res.devices) !== null && _a !== void 0 ? _a : []).map((d) => {
+                var _a, _b, _c;
+                return ({
+                    deviceId: d.device_id,
+                    displayName: (_a = d.display_name) !== null && _a !== void 0 ? _a : undefined,
+                    lastSeenTs: (_b = d.last_seen_ts) !== null && _b !== void 0 ? _b : undefined,
+                    lastSeenIp: (_c = d.last_seen_ip) !== null && _c !== void 0 ? _c : undefined,
+                });
+            });
+            return { devices };
+        }
+        async deleteDevice(options) {
+            this.requireClient();
+            await this.client.deleteDevice(options.deviceId, options.auth);
+        }
+        // ── Push ──────────────────────────────────────────────
+        async setPusher(options) {
+            var _a;
+            this.requireClient();
+            await this.client.setPusher({
+                pushkey: options.pushkey,
+                kind: (_a = options.kind) !== null && _a !== void 0 ? _a : undefined,
+                app_id: options.appId,
+                app_display_name: options.appDisplayName,
+                device_display_name: options.deviceDisplayName,
+                lang: options.lang,
+                data: options.data,
+            });
+        }
+        // ── Encryption ──────────────────────────────────────────
+        async initializeCrypto() {
+            this.requireClient();
+            const userId = this.client.getUserId();
+            const deviceId = this.client.getDeviceId();
+            await this.client.initRustCrypto({
+                cryptoDatabasePrefix: `matrix-js-sdk/${userId}/${deviceId}`,
+            });
+        }
+        async getEncryptionStatus() {
+            this.requireClient();
+            const crypto = this.client.getCrypto();
+            if (!crypto) {
+                return {
+                    isCrossSigningReady: false,
+                    crossSigningStatus: { hasMaster: false, hasSelfSigning: false, hasUserSigning: false, isReady: false },
+                    isKeyBackupEnabled: false,
+                    isSecretStorageReady: false,
+                };
+            }
+            const csReady = await crypto.isCrossSigningReady();
+            const csStatus = await crypto.getCrossSigningStatus();
+            const backupVersion = await crypto.getActiveSessionBackupVersion();
+            // Use getSecretStorageStatus().defaultKeyId to check if secret storage was
+            // set up at all, rather than isSecretStorageReady() which also checks that
+            // cross-signing keys are stored (too strict for Phase 1).
+            const ssStatus = await crypto.getSecretStorageStatus();
+            const ssHasKey = ssStatus.defaultKeyId !== null;
+            return {
+                isCrossSigningReady: csReady,
+                crossSigningStatus: {
+                    hasMaster: csStatus.publicKeysOnDevice,
+                    hasSelfSigning: csStatus.privateKeysCachedLocally.selfSigningKey,
+                    hasUserSigning: csStatus.privateKeysCachedLocally.userSigningKey,
+                    isReady: csReady,
+                },
+                isKeyBackupEnabled: backupVersion !== null,
+                keyBackupVersion: backupVersion !== null && backupVersion !== void 0 ? backupVersion : undefined,
+                isSecretStorageReady: ssHasKey,
+            };
+        }
+        async bootstrapCrossSigning() {
+            const crypto = await this.ensureCrypto();
+            await crypto.bootstrapCrossSigning({
+                setupNewCrossSigning: true,
+                authUploadDeviceSigningKeys: async (makeRequest) => {
+                    var _a;
+                    // UIA flow: attempt with dummy auth, fall back to session-based retry
+                    try {
+                        await makeRequest({ type: 'm.login.dummy' });
+                    }
+                    catch (e) {
+                        const session = (_a = e === null || e === void 0 ? void 0 : e.data) === null || _a === void 0 ? void 0 : _a.session;
+                        if (session) {
+                            await makeRequest({ type: 'm.login.dummy', session });
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                },
+            });
+        }
+        async setupKeyBackup() {
+            const crypto = await this.ensureCrypto();
+            await crypto.resetKeyBackup();
+            const version = await crypto.getActiveSessionBackupVersion();
+            return { exists: true, version: version !== null && version !== void 0 ? version : undefined, enabled: true };
+        }
+        async getKeyBackupStatus() {
+            this.requireClient();
+            const crypto = this.requireCrypto();
+            const version = await crypto.getActiveSessionBackupVersion();
+            return {
+                exists: version !== null,
+                version: version !== null && version !== void 0 ? version : undefined,
+                enabled: version !== null,
+            };
+        }
+        async restoreKeyBackup(_options) {
+            var _a;
+            this.requireClient();
+            const crypto = this.requireCrypto();
+            const result = await crypto.restoreKeyBackup();
+            return { importedKeys: (_a = result === null || result === void 0 ? void 0 : result.imported) !== null && _a !== void 0 ? _a : 0 };
+        }
+        async setupRecovery(options) {
+            var _a;
+            const crypto = await this.ensureCrypto();
+            const keyInfo = await crypto.createRecoveryKeyFromPassphrase(options === null || options === void 0 ? void 0 : options.passphrase);
+            this.secretStorageKey = keyInfo.privateKey;
+            await crypto.bootstrapSecretStorage({
+                createSecretStorageKey: async () => keyInfo,
+                setupNewSecretStorage: true,
+                setupNewKeyBackup: true,
+            });
+            return { recoveryKey: (_a = keyInfo.encodedPrivateKey) !== null && _a !== void 0 ? _a : '' };
+        }
+        async isRecoveryEnabled() {
+            const crypto = await this.ensureCrypto();
+            const ready = await crypto.isSecretStorageReady();
+            return { enabled: ready };
+        }
+        async recoverAndSetup(options) {
+            const crypto = await this.ensureCrypto();
+            // Derive/decode the secret storage key
+            if (options.recoveryKey) {
+                this.secretStorageKey = recoveryKey.decodeRecoveryKey(options.recoveryKey);
+            }
+            else if (options.passphrase) {
+                // Store passphrase — the getSecretStorageKey callback will derive
+                // the key using the server's stored PBKDF2 params (salt, iterations)
+                this.recoveryPassphrase = options.passphrase;
+                this.secretStorageKey = undefined; // Clear any stale raw key
+            }
+            else {
+                throw new Error('Either recoveryKey or passphrase must be provided');
+            }
+            // Load the backup decryption key from secret storage into the Rust crypto store.
+            // This triggers the getSecretStorageKey callback.
+            try {
+                await crypto.loadSessionBackupPrivateKeyFromSecretStorage();
+            }
+            catch (e) {
+                // Clear stale key material so the next attempt starts fresh
+                this.secretStorageKey = undefined;
+                this.recoveryPassphrase = undefined;
+                throw e;
+            }
+            // Now that the key is stored locally, activate backup in the running client
+            await crypto.checkKeyBackupAndEnable();
+        }
+        async resetRecoveryKey(options) {
+            return this.setupRecovery(options);
+        }
+        async exportRoomKeys(options) {
+            this.requireClient();
+            const crypto = this.requireCrypto();
+            const keys = await crypto.exportRoomKeysAsJson();
+            // The exported JSON is not encrypted by default; for passphrase encryption
+            // the caller should handle it, or we return the raw JSON
+            void options.passphrase; // passphrase encryption is handled natively; on web we return raw
+            return { data: keys };
+        }
+        async importRoomKeys(options) {
+            this.requireClient();
+            const crypto = this.requireCrypto();
+            void options.passphrase; // passphrase decryption handled natively; on web we import raw
+            await crypto.importRoomKeysAsJson(options.data);
+            return { importedKeys: -1 }; // count not available from importRoomKeysAsJson
+        }
+        // ── Helpers ───────────────────────────────────────────
+        requireClient() {
+            if (!this.client) {
+                throw new Error('Not logged in. Call login() or loginWithToken() first.');
+            }
+        }
+        requireCrypto() {
+            const crypto = this.client.getCrypto();
+            if (!crypto) {
+                throw new Error('Crypto not initialized. Call initializeCrypto() first.');
+            }
+            return crypto;
+        }
+        async ensureCrypto() {
+            this.requireClient();
+            if (!this.client.getCrypto()) {
+                await this.initializeCrypto();
+            }
+            return this.requireCrypto();
+        }
+        persistSession(session) {
+            localStorage.setItem(SESSION_KEY, JSON.stringify(session));
+        }
+        serializeEvent(event, fallbackRoomId) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const roomId = (_b = (_a = event.getRoomId()) !== null && _a !== void 0 ? _a : fallbackRoomId) !== null && _b !== void 0 ? _b : '';
+            // Redacted events should be marked clearly
+            if (event.isRedacted()) {
+                return {
+                    eventId: (_c = event.getId()) !== null && _c !== void 0 ? _c : '',
+                    roomId,
+                    senderId: (_d = event.getSender()) !== null && _d !== void 0 ? _d : '',
+                    type: 'm.room.redaction',
+                    content: { body: 'Message deleted' },
+                    originServerTs: event.getTs(),
+                };
+            }
+            const content = Object.assign({}, ((_e = event.getContent()) !== null && _e !== void 0 ? _e : {}));
+            // Include aggregated reactions from the room's relations container
+            const eventId = event.getId();
+            if (eventId && roomId) {
+                const room = (_f = this.client) === null || _f === void 0 ? void 0 : _f.getRoom(roomId);
+                if (room) {
+                    try {
+                        const relations = room.relations.getChildEventsForEvent(eventId, matrixJsSdk.RelationType.Annotation, matrixJsSdk.EventType.Reaction);
+                        if (relations) {
+                            const sorted = relations.getSortedAnnotationsByKey();
+                            if (sorted && sorted.length > 0) {
+                                content.reactions = sorted.map(([key, events]) => ({
+                                    key,
+                                    count: events.size,
+                                    senders: Array.from(events).map((e) => e.getSender()),
+                                }));
+                            }
+                        }
+                    }
+                    catch (_k) {
+                        // relations may not be available
+                    }
+                }
+            }
+            // Determine delivery/read status
+            let status;
+            const readBy = [];
+            const myUserId = (_g = this.client) === null || _g === void 0 ? void 0 : _g.getUserId();
+            const sender = event.getSender();
+            const room = eventId && roomId ? (_h = this.client) === null || _h === void 0 ? void 0 : _h.getRoom(roomId) : undefined;
+            if (sender === myUserId && eventId) {
+                // Own message — check delivery status
+                const evtStatus = event.status; // null = sent & echoed, 'sending', 'sent', etc.
+                if (evtStatus === 'sending' || evtStatus === 'encrypting' || evtStatus === 'queued') {
+                    status = 'sending';
+                }
+                else {
+                    // Event is at least sent; check if anyone has read it
+                    if (room) {
+                        try {
+                            const members = room.getJoinedMembers();
+                            for (const member of members) {
+                                if (member.userId === myUserId)
+                                    continue;
+                                if (room.hasUserReadEvent(member.userId, eventId)) {
+                                    readBy.push(member.userId);
+                                }
+                            }
+                        }
+                        catch (_l) {
+                            // ignore errors
+                        }
+                    }
+                    status = readBy.length > 0 ? 'read' : 'sent';
+                }
+            }
+            else if (eventId && room) {
+                // Other's message — collect who has read it
+                try {
+                    const members = room.getJoinedMembers();
+                    for (const member of members) {
+                        if (member.userId === sender)
+                            continue;
+                        if (room.hasUserReadEvent(member.userId, eventId)) {
+                            readBy.push(member.userId);
+                        }
+                    }
+                }
+                catch (_m) {
+                    // ignore
+                }
+            }
+            // Include unsigned data (e.g. m.relations for edits, transaction_id for local echo)
+            const unsignedData = (_j = event.getUnsigned) === null || _j === void 0 ? void 0 : _j.call(event);
+            const unsigned = unsignedData && Object.keys(unsignedData).length > 0
+                ? unsignedData
+                : undefined;
+            return {
+                eventId: eventId !== null && eventId !== void 0 ? eventId : '',
+                roomId,
+                senderId: sender !== null && sender !== void 0 ? sender : '',
+                type: event.getType(),
+                content,
+                originServerTs: event.getTs(),
+                status,
+                readBy: readBy.length > 0 ? readBy : undefined,
+                unsigned,
+            };
+        }
+        serializeRoom(room) {
+            var _a, _b, _c, _d, _e, _f;
+            // Detect DM: check m.direct account data or guess from room state
+            let isDirect = false;
+            try {
+                const directEvent = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getAccountData('m.direct');
+                if (directEvent) {
+                    const directContent = directEvent.getContent();
+                    for (const roomIds of Object.values(directContent)) {
+                        if (roomIds.includes(room.roomId)) {
+                            isDirect = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (_g) {
+                // ignore
+            }
+            // Get avatar URL
+            let avatarUrl;
+            const avatarEvent = room.currentState.getStateEvents('m.room.avatar', '');
+            if (avatarEvent) {
+                const mxcUrl = (_b = avatarEvent.getContent()) === null || _b === void 0 ? void 0 : _b.url;
+                if (mxcUrl) {
+                    avatarUrl = mxcUrl;
+                }
+            }
+            return {
+                roomId: room.roomId,
+                name: room.name,
+                topic: (_e = (_d = (_c = room.currentState.getStateEvents('m.room.topic', '')) === null || _c === void 0 ? void 0 : _c.getContent()) === null || _d === void 0 ? void 0 : _d.topic) !== null && _e !== void 0 ? _e : undefined,
+                memberCount: room.getJoinedMemberCount(),
+                isEncrypted: room.hasEncryptionStateEvent(),
+                unreadCount: (_f = room.getUnreadNotificationCount()) !== null && _f !== void 0 ? _f : 0,
+                lastEventTs: room.getLastActiveTimestamp() || undefined,
+                membership: room.getMyMembership(),
+                avatarUrl,
+                isDirect,
+            };
+        }
+        async searchUsers(options) {
+            var _a;
+            this.requireClient();
+            const resp = await this.client.searchUserDirectory({
+                term: options.searchTerm,
+                limit: (_a = options.limit) !== null && _a !== void 0 ? _a : 10,
+            });
+            return {
+                results: resp.results.map((u) => ({
+                    userId: u.user_id,
+                    displayName: u.display_name,
+                    avatarUrl: u.avatar_url,
+                })),
+                limited: resp.limited,
+            };
+        }
+        mapSyncState(state) {
+            switch (state) {
+                case 'PREPARED':
+                case 'SYNCING':
+                case 'CATCHUP':
+                case 'RECONNECTING':
+                    return 'SYNCING';
+                case 'ERROR':
+                    return 'ERROR';
+                case 'STOPPED':
+                    return 'STOPPED';
+                default:
+                    return 'INITIAL';
+            }
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        MatrixWeb: MatrixWeb
+    });
+
+    exports.Matrix = Matrix;
+
+    return exports;
+
+})({}, capacitorExports, matrixJsSdk, recoveryKey, keyPassphrase);
+//# sourceMappingURL=plugin.js.map