matrix-react-sdk
Version:
SDK for matrix.org using React
181 lines (167 loc) • 23.6 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.useFetchedPinnedEvents = useFetchedPinnedEvents;
exports.useReadPinnedEvents = exports.usePinnedEvents = void 0;
exports.useSortedFetchedPinnedEvents = useSortedFetchedPinnedEvents;
var _react = require("react");
var _matrix = require("matrix-js-sdk/src/matrix");
var _logger = require("matrix-js-sdk/src/logger");
var _useEventEmitter = require("./useEventEmitter");
var _types = require("../components/views/right_panel/types");
var _MatrixClientContext = require("../contexts/MatrixClientContext");
var _useAsyncMemo = require("./useAsyncMemo");
var _PinningUtils = _interopRequireDefault(require("../utils/PinningUtils"));
var _promise = require("../utils/promise.ts");
/*
* Copyright 2024 New Vector Ltd.
* Copyright 2024 The Matrix.org Foundation C.I.C.
*
* SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
* Please see LICENSE files in the repository root for full details.
*/
/**
* Get the pinned event IDs from a room.
* The number of pinned events is limited to 100.
* @param room
*/
function getPinnedEventIds(room) {
const eventIds = room?.getLiveTimeline().getState(_matrix.EventTimeline.FORWARDS)?.getStateEvents(_matrix.EventType.RoomPinnedEvents, "")?.getContent()?.pinned ?? [];
// Limit the number of pinned events to 100
return eventIds.slice(0, 100);
}
/**
* Get the pinned event IDs from a room.
* @param room
*/
const usePinnedEvents = room => {
const [pinnedEvents, setPinnedEvents] = (0, _react.useState)(getPinnedEventIds(room));
// Update the pinned events when the room state changes
// Filter out events that are not pinned events
const update = (0, _react.useCallback)(ev => {
if (ev && ev.getType() !== _matrix.EventType.RoomPinnedEvents) return;
setPinnedEvents(getPinnedEventIds(room));
}, [room]);
(0, _useEventEmitter.useTypedEventEmitter)(room?.getLiveTimeline().getState(_matrix.EventTimeline.FORWARDS), _matrix.RoomStateEvent.Events, update);
(0, _react.useEffect)(() => {
setPinnedEvents(getPinnedEventIds(room));
return () => {
setPinnedEvents([]);
};
}, [room]);
return pinnedEvents;
};
/**
* Get the read pinned event IDs from a room.
* @param room
*/
exports.usePinnedEvents = usePinnedEvents;
function getReadPinnedEventIds(room) {
return new Set(room?.getAccountData(_types.ReadPinsEventId)?.getContent()?.event_ids ?? []);
}
/**
* Get the read pinned event IDs from a room.
* @param room
*/
const useReadPinnedEvents = room => {
const [readPinnedEvents, setReadPinnedEvents] = (0, _react.useState)(new Set());
// Update the read pinned events when the room state changes
// Filter out events that are not read pinned events
const update = (0, _react.useCallback)(ev => {
if (ev && ev.getType() !== _types.ReadPinsEventId) return;
setReadPinnedEvents(getReadPinnedEventIds(room));
}, [room]);
(0, _useEventEmitter.useTypedEventEmitter)(room, _matrix.RoomEvent.AccountData, update);
(0, _react.useEffect)(() => {
setReadPinnedEvents(getReadPinnedEventIds(room));
return () => {
setReadPinnedEvents(new Set());
};
}, [room]);
return readPinnedEvents;
};
/**
* Fetch the pinned event
* @param room
* @param pinnedEventId
* @param cli
*/
exports.useReadPinnedEvents = useReadPinnedEvents;
async function fetchPinnedEvent(room, pinnedEventId, cli) {
const timelineSet = room.getUnfilteredTimelineSet();
// Get the event from the local timeline
const localEvent = timelineSet?.getTimelineForEvent(pinnedEventId)?.getEvents().find(e => e.getId() === pinnedEventId);
// Decrypt the event if it's encrypted
// Can happen when the tab is refreshed and the pinned events card is opened directly
if (localEvent?.isEncrypted()) {
await cli.decryptEventIfNeeded(localEvent, {
emit: false
});
}
// If the event is available locally, return it if it's pinnable
// or if it's redacted (to show the redacted event and to be able to unpin it)
// Otherwise, return null
if (localEvent) return _PinningUtils.default.isUnpinnable(localEvent) ? localEvent : null;
try {
// The event is not available locally, so we fetch the event and latest edit in parallel
const [evJson, {
events: [edit]
}] = await Promise.all([cli.fetchRoomEvent(room.roomId, pinnedEventId), cli.relations(room.roomId, pinnedEventId, _matrix.RelationType.Replace, null, {
limit: 1
})]);
const event = new _matrix.MatrixEvent(evJson);
// Decrypt the event if it's encrypted
if (event.isEncrypted()) {
await cli.decryptEventIfNeeded(event, {
emit: false
});
}
// Handle poll events
await room.processPollEvents([event]);
const senderUserId = event.getSender();
if (senderUserId && _PinningUtils.default.isUnpinnable(event)) {
// Inject sender information
event.sender = room.getMember(senderUserId);
// Also inject any edits we've found
if (edit) event.makeReplaced(edit);
return event;
}
} catch (err) {
_logger.logger.error(`Error looking up pinned event ${pinnedEventId} in room ${room.roomId}`);
_logger.logger.error(err);
}
return null;
}
/**
* Fetch the pinned events
* @param room
* @param pinnedEventIds
*/
function useFetchedPinnedEvents(room, pinnedEventIds) {
const cli = (0, _MatrixClientContext.useMatrixClientContext)();
return (0, _useAsyncMemo.useAsyncMemo)(() => {
const fetchPromises = pinnedEventIds.map(eventId => () => fetchPinnedEvent(room, eventId, cli));
// Fetch the pinned events in batches of 10
return (0, _promise.batch)(fetchPromises, 10);
}, [cli, room, pinnedEventIds], null);
}
/**
* Fetch the pinned events and sort them by from the oldest to the newest
* The order is determined by the event timestamp
* @param room
* @param pinnedEventIds
*/
function useSortedFetchedPinnedEvents(room, pinnedEventIds) {
const pinnedEvents = useFetchedPinnedEvents(room, pinnedEventIds);
return (0, _react.useMemo)(() => {
if (!pinnedEvents) return [];
return pinnedEvents.sort((a, b) => {
if (!a) return -1;
if (!b) return 1;
return a.getTs() - b.getTs();
});
}, [pinnedEvents]);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_matrix","_logger","_useEventEmitter","_types","_MatrixClientContext","_useAsyncMemo","_PinningUtils","_interopRequireDefault","_promise","getPinnedEventIds","room","eventIds","getLiveTimeline","getState","EventTimeline","FORWARDS","getStateEvents","EventType","RoomPinnedEvents","getContent","pinned","slice","usePinnedEvents","pinnedEvents","setPinnedEvents","useState","update","useCallback","ev","getType","useTypedEventEmitter","RoomStateEvent","Events","useEffect","exports","getReadPinnedEventIds","Set","getAccountData","ReadPinsEventId","event_ids","useReadPinnedEvents","readPinnedEvents","setReadPinnedEvents","RoomEvent","AccountData","fetchPinnedEvent","pinnedEventId","cli","timelineSet","getUnfilteredTimelineSet","localEvent","getTimelineForEvent","getEvents","find","e","getId","isEncrypted","decryptEventIfNeeded","emit","PinningUtils","isUnpinnable","evJson","events","edit","Promise","all","fetchRoomEvent","roomId","relations","RelationType","Replace","limit","event","MatrixEvent","processPollEvents","senderUserId","getSender","sender","getMember","makeReplaced","err","logger","error","useFetchedPinnedEvents","pinnedEventIds","useMatrixClientContext","useAsyncMemo","fetchPromises","map","eventId","batch","useSortedFetchedPinnedEvents","useMemo","sort","a","b","getTs"],"sources":["../../src/hooks/usePinnedEvents.ts"],"sourcesContent":["/*\n * Copyright 2024 New Vector Ltd.\n * Copyright 2024 The Matrix.org Foundation C.I.C.\n *\n * SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\n * Please see LICENSE files in the repository root for full details.\n */\n\nimport { useCallback, useEffect, useMemo, useState } from \"react\";\nimport {\n    Room,\n    RoomEvent,\n    RoomStateEvent,\n    MatrixEvent,\n    EventType,\n    RelationType,\n    EventTimeline,\n    MatrixClient,\n} from \"matrix-js-sdk/src/matrix\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\n\nimport { useTypedEventEmitter } from \"./useEventEmitter\";\nimport { ReadPinsEventId } from \"../components/views/right_panel/types\";\nimport { useMatrixClientContext } from \"../contexts/MatrixClientContext\";\nimport { useAsyncMemo } from \"./useAsyncMemo\";\nimport PinningUtils from \"../utils/PinningUtils\";\nimport { batch } from \"../utils/promise.ts\";\n\n/**\n * Get the pinned event IDs from a room.\n * The number of pinned events is limited to 100.\n * @param room\n */\nfunction getPinnedEventIds(room?: Room): string[] {\n    const eventIds: string[] =\n        room\n            ?.getLiveTimeline()\n            .getState(EventTimeline.FORWARDS)\n            ?.getStateEvents(EventType.RoomPinnedEvents, \"\")\n            ?.getContent()?.pinned ?? [];\n    // Limit the number of pinned events to 100\n    return eventIds.slice(0, 100);\n}\n\n/**\n * Get the pinned event IDs from a room.\n * @param room\n */\nexport const usePinnedEvents = (room?: Room): string[] => {\n    const [pinnedEvents, setPinnedEvents] = useState<string[]>(getPinnedEventIds(room));\n\n    // Update the pinned events when the room state changes\n    // Filter out events that are not pinned events\n    const update = useCallback(\n        (ev?: MatrixEvent) => {\n            if (ev && ev.getType() !== EventType.RoomPinnedEvents) return;\n            setPinnedEvents(getPinnedEventIds(room));\n        },\n        [room],\n    );\n\n    useTypedEventEmitter(room?.getLiveTimeline().getState(EventTimeline.FORWARDS), RoomStateEvent.Events, update);\n    useEffect(() => {\n        setPinnedEvents(getPinnedEventIds(room));\n        return () => {\n            setPinnedEvents([]);\n        };\n    }, [room]);\n    return pinnedEvents;\n};\n\n/**\n * Get the read pinned event IDs from a room.\n * @param room\n */\nfunction getReadPinnedEventIds(room?: Room): Set<string> {\n    return new Set(room?.getAccountData(ReadPinsEventId)?.getContent()?.event_ids ?? []);\n}\n\n/**\n * Get the read pinned event IDs from a room.\n * @param room\n */\nexport const useReadPinnedEvents = (room?: Room): Set<string> => {\n    const [readPinnedEvents, setReadPinnedEvents] = useState<Set<string>>(new Set());\n\n    // Update the read pinned events when the room state changes\n    // Filter out events that are not read pinned events\n    const update = useCallback(\n        (ev?: MatrixEvent) => {\n            if (ev && ev.getType() !== ReadPinsEventId) return;\n            setReadPinnedEvents(getReadPinnedEventIds(room));\n        },\n        [room],\n    );\n\n    useTypedEventEmitter(room, RoomEvent.AccountData, update);\n    useEffect(() => {\n        setReadPinnedEvents(getReadPinnedEventIds(room));\n        return () => {\n            setReadPinnedEvents(new Set());\n        };\n    }, [room]);\n    return readPinnedEvents;\n};\n\n/**\n * Fetch the pinned event\n * @param room\n * @param pinnedEventId\n * @param cli\n */\nasync function fetchPinnedEvent(room: Room, pinnedEventId: string, cli: MatrixClient): Promise<MatrixEvent | null> {\n    const timelineSet = room.getUnfilteredTimelineSet();\n    // Get the event from the local timeline\n    const localEvent = timelineSet\n        ?.getTimelineForEvent(pinnedEventId)\n        ?.getEvents()\n        .find((e) => e.getId() === pinnedEventId);\n\n    // Decrypt the event if it's encrypted\n    // Can happen when the tab is refreshed and the pinned events card is opened directly\n    if (localEvent?.isEncrypted()) {\n        await cli.decryptEventIfNeeded(localEvent, { emit: false });\n    }\n\n    // If the event is available locally, return it if it's pinnable\n    // or if it's redacted (to show the redacted event and to be able to unpin it)\n    // Otherwise, return null\n    if (localEvent) return PinningUtils.isUnpinnable(localEvent) ? localEvent : null;\n\n    try {\n        // The event is not available locally, so we fetch the event and latest edit in parallel\n        const [\n            evJson,\n            {\n                events: [edit],\n            },\n        ] = await Promise.all([\n            cli.fetchRoomEvent(room.roomId, pinnedEventId),\n            cli.relations(room.roomId, pinnedEventId, RelationType.Replace, null, { limit: 1 }),\n        ]);\n\n        const event = new MatrixEvent(evJson);\n\n        // Decrypt the event if it's encrypted\n        if (event.isEncrypted()) {\n            await cli.decryptEventIfNeeded(event, { emit: false });\n        }\n\n        // Handle poll events\n        await room.processPollEvents([event]);\n\n        const senderUserId = event.getSender();\n        if (senderUserId && PinningUtils.isUnpinnable(event)) {\n            // Inject sender information\n            event.sender = room.getMember(senderUserId);\n            // Also inject any edits we've found\n            if (edit) event.makeReplaced(edit);\n\n            return event;\n        }\n    } catch (err) {\n        logger.error(`Error looking up pinned event ${pinnedEventId} in room ${room.roomId}`);\n        logger.error(err);\n    }\n    return null;\n}\n\n/**\n * Fetch the pinned events\n * @param room\n * @param pinnedEventIds\n */\nexport function useFetchedPinnedEvents(room: Room, pinnedEventIds: string[]): Array<MatrixEvent | null> | null {\n    const cli = useMatrixClientContext();\n\n    return useAsyncMemo(\n        () => {\n            const fetchPromises = pinnedEventIds.map((eventId) => () => fetchPinnedEvent(room, eventId, cli));\n            // Fetch the pinned events in batches of 10\n            return batch(fetchPromises, 10);\n        },\n        [cli, room, pinnedEventIds],\n        null,\n    );\n}\n\n/**\n * Fetch the pinned events and sort them by from the oldest to the newest\n * The order is determined by the event timestamp\n * @param room\n * @param pinnedEventIds\n */\nexport function useSortedFetchedPinnedEvents(room: Room, pinnedEventIds: string[]): Array<MatrixEvent | null> {\n    const pinnedEvents = useFetchedPinnedEvents(room, pinnedEventIds);\n    return useMemo(() => {\n        if (!pinnedEvents) return [];\n\n        return pinnedEvents.sort((a, b) => {\n            if (!a) return -1;\n            if (!b) return 1;\n            return a.getTs() - b.getTs();\n        });\n    }, [pinnedEvents]);\n}\n"],"mappings":"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","ignoreList":[]}