matrix-react-sdk
Version:
SDK for matrix.org using React
166 lines (160 loc) • 23.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.useFetchPastPolls = void 0;
var _react = require("react");
var _matrix = require("matrix-js-sdk/src/matrix");
var _logger = require("matrix-js-sdk/src/logger");
/*
Copyright 2024 New Vector Ltd.
Copyright 2023 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.
*/
const getOldestEventTimestamp = timelineSet => {
if (!timelineSet) {
return;
}
const liveTimeline = timelineSet?.getLiveTimeline();
const events = liveTimeline.getEvents();
return events[0]?.getTs();
};
/**
* Page backwards in timeline history
* @param timelineSet - timelineset to page
* @param matrixClient - client
* @param canPageBackward - whether the timeline has more pages
* @param oldestEventTimestamp - server ts of the oldest encountered event
*/
const pagePollHistory = async (timelineSet, matrixClient) => {
if (!timelineSet) {
return {
canPageBackward: false
};
}
const liveTimeline = timelineSet.getLiveTimeline();
await matrixClient.paginateEventTimeline(liveTimeline, {
backwards: true
});
return {
oldestEventTimestamp: getOldestEventTimestamp(timelineSet),
canPageBackward: !!liveTimeline.getPaginationToken(_matrix.EventTimeline.BACKWARDS)
};
};
/**
* Page timeline backwards until either:
* - event older than timestamp is encountered
* - end of timeline is reached
* @param timelineSet - timeline set to page
* @param matrixClient - client
* @param timestamp - epoch timestamp to page until
* @param canPageBackward - whether the timeline has more pages
* @param oldestEventTimestamp - server ts of the oldest encountered event
*/
const fetchHistoryUntilTimestamp = async (timelineSet, matrixClient, timestamp, canPageBackward, oldestEventTimestamp) => {
if (!timelineSet || !canPageBackward || oldestEventTimestamp && oldestEventTimestamp < timestamp) {
return;
}
const result = await pagePollHistory(timelineSet, matrixClient);
return fetchHistoryUntilTimestamp(timelineSet, matrixClient, timestamp, result.canPageBackward, result.oldestEventTimestamp);
};
const ONE_DAY_MS = 60000 * 60 * 24;
/**
* Fetches timeline history for given number of days in past
* @param timelineSet - timelineset to page
* @param matrixClient - client
* @param historyPeriodDays - number of days of history to fetch, from current day
* @returns isLoading - true while fetching
* @returns oldestEventTimestamp - timestamp of oldest encountered poll, undefined when no polls found in timeline so far
* @returns loadMorePolls - function to page timeline backwards, undefined when timeline cannot be paged backwards
* @returns loadTimelineHistory - loads timeline history for the given history period
*/
const useTimelineHistory = (timelineSet, matrixClient, historyPeriodDays) => {
const [isLoading, setIsLoading] = (0, _react.useState)(true);
const [oldestEventTimestamp, setOldestEventTimestamp] = (0, _react.useState)(undefined);
const [canPageBackward, setCanPageBackward] = (0, _react.useState)(false);
const loadTimelineHistory = (0, _react.useCallback)(async () => {
const endOfHistoryPeriodTimestamp = Date.now() - ONE_DAY_MS * historyPeriodDays;
setIsLoading(true);
try {
const liveTimeline = timelineSet?.getLiveTimeline();
const canPageBackward = !!liveTimeline?.getPaginationToken(_matrix.Direction.Backward);
const oldestEventTimestamp = getOldestEventTimestamp(timelineSet);
await fetchHistoryUntilTimestamp(timelineSet, matrixClient, endOfHistoryPeriodTimestamp, canPageBackward, oldestEventTimestamp);
setCanPageBackward(!!timelineSet?.getLiveTimeline()?.getPaginationToken(_matrix.EventTimeline.BACKWARDS));
setOldestEventTimestamp(getOldestEventTimestamp(timelineSet));
} catch (error) {
_logger.logger.error("Failed to fetch room polls history", error);
} finally {
setIsLoading(false);
}
}, [historyPeriodDays, timelineSet, matrixClient]);
const loadMorePolls = (0, _react.useCallback)(async () => {
if (!timelineSet) {
return;
}
setIsLoading(true);
try {
const result = await pagePollHistory(timelineSet, matrixClient);
setCanPageBackward(result.canPageBackward);
setOldestEventTimestamp(result.oldestEventTimestamp);
} catch (error) {
_logger.logger.error("Failed to fetch room polls history", error);
} finally {
setIsLoading(false);
}
}, [timelineSet, matrixClient]);
return {
isLoading,
oldestEventTimestamp,
loadTimelineHistory,
loadMorePolls: canPageBackward ? loadMorePolls : undefined
};
};
const filterDefinition = {
room: {
timeline: {
types: [_matrix.M_POLL_START.name, _matrix.M_POLL_START.altName]
}
}
};
/**
* Fetches poll start events in the last N days of room history
* @param room - room to fetch history for
* @param matrixClient - client
* @param historyPeriodDays - number of days of history to fetch, from current day
* @returns isLoading - true while fetching history
* @returns oldestEventTimestamp - timestamp of oldest encountered poll, undefined when no polls found in timeline so far
* @returns loadMorePolls - function to page timeline backwards, undefined when timeline cannot be paged backwards
*/
const useFetchPastPolls = (room, matrixClient, historyPeriodDays = 30) => {
const [timelineSet, setTimelineSet] = (0, _react.useState)(undefined);
(0, _react.useEffect)(() => {
const filter = new _matrix.Filter(matrixClient.getSafeUserId());
filter.setDefinition(filterDefinition);
const getFilteredTimelineSet = async () => {
const filterId = await matrixClient.getOrCreateFilter(`POLL_HISTORY_FILTER_${room.roomId}}`, filter);
filter.filterId = filterId;
const timelineSet = room.getOrCreateFilteredTimelineSet(filter);
setTimelineSet(timelineSet);
};
getFilteredTimelineSet();
}, [room, matrixClient]);
const {
isLoading,
oldestEventTimestamp,
loadMorePolls,
loadTimelineHistory
} = useTimelineHistory(timelineSet, matrixClient, historyPeriodDays);
(0, _react.useEffect)(() => {
loadTimelineHistory();
}, [loadTimelineHistory]);
return {
isLoading,
oldestEventTimestamp,
loadMorePolls
};
};
exports.useFetchPastPolls = useFetchPastPolls;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_matrix","_logger","getOldestEventTimestamp","timelineSet","liveTimeline","getLiveTimeline","events","getEvents","getTs","pagePollHistory","matrixClient","canPageBackward","paginateEventTimeline","backwards","oldestEventTimestamp","getPaginationToken","EventTimeline","BACKWARDS","fetchHistoryUntilTimestamp","timestamp","result","ONE_DAY_MS","useTimelineHistory","historyPeriodDays","isLoading","setIsLoading","useState","setOldestEventTimestamp","undefined","setCanPageBackward","loadTimelineHistory","useCallback","endOfHistoryPeriodTimestamp","Date","now","Direction","Backward","error","logger","loadMorePolls","filterDefinition","room","timeline","types","M_POLL_START","name","altName","useFetchPastPolls","setTimelineSet","useEffect","filter","Filter","getSafeUserId","setDefinition","getFilteredTimelineSet","filterId","getOrCreateFilter","roomId","getOrCreateFilteredTimelineSet","exports"],"sources":["../../../../../src/components/views/polls/pollHistory/fetchPastPolls.ts"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { useCallback, useEffect, useState } from \"react\";\nimport {\n    M_POLL_START,\n    MatrixClient,\n    Direction,\n    EventTimeline,\n    EventTimelineSet,\n    Room,\n    Filter,\n    IFilterDefinition,\n} from \"matrix-js-sdk/src/matrix\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\n\nconst getOldestEventTimestamp = (timelineSet?: EventTimelineSet): number | undefined => {\n    if (!timelineSet) {\n        return;\n    }\n\n    const liveTimeline = timelineSet?.getLiveTimeline();\n    const events = liveTimeline.getEvents();\n    return events[0]?.getTs();\n};\n\n/**\n * Page backwards in timeline history\n * @param timelineSet - timelineset to page\n * @param matrixClient - client\n * @param canPageBackward - whether the timeline has more pages\n * @param oldestEventTimestamp - server ts of the oldest encountered event\n */\nconst pagePollHistory = async (\n    timelineSet: EventTimelineSet,\n    matrixClient: MatrixClient,\n): Promise<{\n    oldestEventTimestamp?: number;\n    canPageBackward: boolean;\n}> => {\n    if (!timelineSet) {\n        return { canPageBackward: false };\n    }\n\n    const liveTimeline = timelineSet.getLiveTimeline();\n\n    await matrixClient.paginateEventTimeline(liveTimeline, {\n        backwards: true,\n    });\n\n    return {\n        oldestEventTimestamp: getOldestEventTimestamp(timelineSet),\n        canPageBackward: !!liveTimeline.getPaginationToken(EventTimeline.BACKWARDS),\n    };\n};\n\n/**\n * Page timeline backwards until either:\n * - event older than timestamp is encountered\n * - end of timeline is reached\n * @param timelineSet - timeline set to page\n * @param matrixClient - client\n * @param timestamp - epoch timestamp to page until\n * @param canPageBackward - whether the timeline has more pages\n * @param oldestEventTimestamp - server ts of the oldest encountered event\n */\nconst fetchHistoryUntilTimestamp = async (\n    timelineSet: EventTimelineSet | undefined,\n    matrixClient: MatrixClient,\n    timestamp: number,\n    canPageBackward: boolean,\n    oldestEventTimestamp?: number,\n): Promise<void> => {\n    if (!timelineSet || !canPageBackward || (oldestEventTimestamp && oldestEventTimestamp < timestamp)) {\n        return;\n    }\n    const result = await pagePollHistory(timelineSet, matrixClient);\n\n    return fetchHistoryUntilTimestamp(\n        timelineSet,\n        matrixClient,\n        timestamp,\n        result.canPageBackward,\n        result.oldestEventTimestamp,\n    );\n};\n\nconst ONE_DAY_MS = 60000 * 60 * 24;\n/**\n * Fetches timeline history for given number of days in past\n * @param timelineSet - timelineset to page\n * @param matrixClient - client\n * @param historyPeriodDays - number of days of history to fetch, from current day\n * @returns isLoading - true while fetching\n * @returns oldestEventTimestamp - timestamp of oldest encountered poll, undefined when no polls found in timeline so far\n * @returns loadMorePolls - function to page timeline backwards, undefined when timeline cannot be paged backwards\n * @returns loadTimelineHistory - loads timeline history for the given history period\n */\nconst useTimelineHistory = (\n    timelineSet: EventTimelineSet | undefined,\n    matrixClient: MatrixClient,\n    historyPeriodDays: number,\n): {\n    isLoading: boolean;\n    oldestEventTimestamp?: number;\n    loadTimelineHistory: () => Promise<void>;\n    loadMorePolls?: () => Promise<void>;\n} => {\n    const [isLoading, setIsLoading] = useState(true);\n    const [oldestEventTimestamp, setOldestEventTimestamp] = useState<number | undefined>(undefined);\n    const [canPageBackward, setCanPageBackward] = useState(false);\n\n    const loadTimelineHistory = useCallback(async () => {\n        const endOfHistoryPeriodTimestamp = Date.now() - ONE_DAY_MS * historyPeriodDays;\n        setIsLoading(true);\n        try {\n            const liveTimeline = timelineSet?.getLiveTimeline();\n            const canPageBackward = !!liveTimeline?.getPaginationToken(Direction.Backward);\n            const oldestEventTimestamp = getOldestEventTimestamp(timelineSet);\n\n            await fetchHistoryUntilTimestamp(\n                timelineSet,\n                matrixClient,\n                endOfHistoryPeriodTimestamp,\n                canPageBackward,\n                oldestEventTimestamp,\n            );\n\n            setCanPageBackward(!!timelineSet?.getLiveTimeline()?.getPaginationToken(EventTimeline.BACKWARDS));\n            setOldestEventTimestamp(getOldestEventTimestamp(timelineSet));\n        } catch (error) {\n            logger.error(\"Failed to fetch room polls history\", error);\n        } finally {\n            setIsLoading(false);\n        }\n    }, [historyPeriodDays, timelineSet, matrixClient]);\n\n    const loadMorePolls = useCallback(async () => {\n        if (!timelineSet) {\n            return;\n        }\n        setIsLoading(true);\n        try {\n            const result = await pagePollHistory(timelineSet, matrixClient);\n\n            setCanPageBackward(result.canPageBackward);\n            setOldestEventTimestamp(result.oldestEventTimestamp);\n        } catch (error) {\n            logger.error(\"Failed to fetch room polls history\", error);\n        } finally {\n            setIsLoading(false);\n        }\n    }, [timelineSet, matrixClient]);\n\n    return {\n        isLoading,\n        oldestEventTimestamp,\n        loadTimelineHistory,\n        loadMorePolls: canPageBackward ? loadMorePolls : undefined,\n    };\n};\n\nconst filterDefinition: IFilterDefinition = {\n    room: {\n        timeline: {\n            types: [M_POLL_START.name, M_POLL_START.altName],\n        },\n    },\n};\n\n/**\n * Fetches poll start events in the last N days of room history\n * @param room - room to fetch history for\n * @param matrixClient - client\n * @param historyPeriodDays - number of days of history to fetch, from current day\n * @returns isLoading - true while fetching history\n * @returns oldestEventTimestamp - timestamp of oldest encountered poll, undefined when no polls found in timeline so far\n * @returns loadMorePolls - function to page timeline backwards, undefined when timeline cannot be paged backwards\n */\nexport const useFetchPastPolls = (\n    room: Room,\n    matrixClient: MatrixClient,\n    historyPeriodDays = 30,\n): {\n    isLoading: boolean;\n    oldestEventTimestamp?: number;\n    loadMorePolls?: () => Promise<void>;\n} => {\n    const [timelineSet, setTimelineSet] = useState<EventTimelineSet | undefined>(undefined);\n\n    useEffect(() => {\n        const filter = new Filter(matrixClient.getSafeUserId());\n        filter.setDefinition(filterDefinition);\n        const getFilteredTimelineSet = async (): Promise<void> => {\n            const filterId = await matrixClient.getOrCreateFilter(`POLL_HISTORY_FILTER_${room.roomId}}`, filter);\n            filter.filterId = filterId;\n            const timelineSet = room.getOrCreateFilteredTimelineSet(filter);\n            setTimelineSet(timelineSet);\n        };\n\n        getFilteredTimelineSet();\n    }, [room, matrixClient]);\n\n    const { isLoading, oldestEventTimestamp, loadMorePolls, loadTimelineHistory } = useTimelineHistory(\n        timelineSet,\n        matrixClient,\n        historyPeriodDays,\n    );\n\n    useEffect(() => {\n        loadTimelineHistory();\n    }, [loadTimelineHistory]);\n\n    return { isLoading, oldestEventTimestamp, loadMorePolls };\n};\n"],"mappings":"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","ignoreList":[]}