Compare commits
8
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
  Lotus CIandClaude Opus 5.5
|
02d86caeb0 | ||
 jared
|
c0c93213c1 | ||
|
Lotus CIandClaude Opus 5.5
|
1ea6987083 | ||
|
jared
|
be8e49a2bb | ||
|
Lotus CIandClaude Opus 5.5
|
1e217592fc | ||
|
jared
|
ffe1d5a81e | ||
|
Lotus CIandClaude Opus 5.5
|
fff583fca5 | ||
|
jared
|
e2b23397bd |
@@ -82,6 +82,7 @@ import { useRoomCallPolicy } from '../hooks/useRoomCallPolicy';
|
||||
import { useNotificationsQuiet } from '../hooks/useNotificationsQuiet';
|
||||
import { CallAvatarAnimation } from '../styles/Animations.css';
|
||||
import { webRTCSupported } from '../utils/rtc';
|
||||
import { CallsUnavailableMessage } from '../features/call/CallsUnavailable';
|
||||
import { zIndices } from '../styles/zIndex';
|
||||
|
||||
const PIP_MIN_W = 200;
|
||||
@@ -231,13 +232,7 @@ function IncomingCall({ dm, info, onIgnore, onAnswer, onReject }: IncomingCallPr
|
||||
</Text>
|
||||
)}
|
||||
{!webRTCSupported() && (
|
||||
<Text
|
||||
style={{ margin: 'auto', color: color.Critical.Main }}
|
||||
size="L400"
|
||||
align="Center"
|
||||
>
|
||||
Your browser does not support WebRTC, which is required for calling.
|
||||
</Text>
|
||||
<CallsUnavailableMessage roomId={room.roomId} actionLabel="Answer in browser" />
|
||||
)}
|
||||
<Box direction="Column" gap="300">
|
||||
{willAnswerWithCamera && (
|
||||
|
||||
@@ -261,52 +261,69 @@ export function PollContent({
|
||||
handleVote(answers[idx].id);
|
||||
};
|
||||
|
||||
const headerLabel = isEnded
|
||||
? 'Poll closed · Final results'
|
||||
: `Poll · ${isMultiple ? 'Multiple choice' : 'Single choice'}`;
|
||||
// [Gitea #246] Type line under the "Poll" label.
|
||||
const typeLabel = (() => {
|
||||
if (isEnded) return 'Final results';
|
||||
if (isUndisclosed) return 'Results hidden until the end';
|
||||
return isMultiple ? `Pick up to ${maxSelections}` : 'Single choice';
|
||||
})();
|
||||
|
||||
// Multiple choice counts people, not answers ("1 voter" who picked two).
|
||||
const unit = isMultiple ? 'voter' : 'vote';
|
||||
const footerNote = (() => {
|
||||
const totalPart = total > 0 ? `${total} ${unit}${total === 1 ? '' : 's'}` : `No ${unit}s yet`;
|
||||
if (isUndisclosed && !isEnded) {
|
||||
return canVote
|
||||
? 'Voting open · Results hidden until the poll ends'
|
||||
: 'Results hidden until the poll ends';
|
||||
? `${myVotes.size > 0 ? 'You voted' : 'Voting open'} · results shown when the poll ends`
|
||||
: 'Results shown when the poll ends';
|
||||
}
|
||||
const votesPart = total > 0 ? `${total} vote${total === 1 ? '' : 's'}` : 'No votes yet';
|
||||
if (isEnded) return `${votesPart} · Poll closed`;
|
||||
if (!canVote) return votesPart;
|
||||
if (isMultiple) return `${votesPart} · Select up to ${maxSelections}`;
|
||||
return `${votesPart} · ${myVotes.size > 0 ? 'Click to change' : 'Click to vote'}`;
|
||||
if (isEnded) return `${totalPart} · Poll closed`;
|
||||
if (!canVote) return totalPart;
|
||||
return `${totalPart} · ${myVotes.size > 0 ? 'Select another answer to change your vote' : 'Select an answer to vote'}`;
|
||||
})();
|
||||
|
||||
// Neutral tones derived from the theme's text colour, so they have contrast
|
||||
// in every theme (the Container/ContainerLine tokens were near-invisible).
|
||||
const muted = (pct: number) =>
|
||||
`color-mix(in srgb, ${color.SurfaceVariant.OnContainer} ${pct}%, transparent)`;
|
||||
|
||||
return (
|
||||
<Box
|
||||
data-poll-content
|
||||
direction="Column"
|
||||
gap="200"
|
||||
style={{ maxWidth: '340px', paddingTop: '2px', paddingBottom: '4px' }}
|
||||
gap="300"
|
||||
style={{
|
||||
// Same width for every poll (the message body shrink-wraps its content).
|
||||
width: toRem(460),
|
||||
maxWidth: '100%',
|
||||
margin: `${config.space.S100} 0`,
|
||||
padding: config.space.S300,
|
||||
borderRadius: config.radii.R400,
|
||||
border: `${config.borderWidth.B300} solid ${muted(18)}`,
|
||||
background: muted(4),
|
||||
boxSizing: 'border-box',
|
||||
}}
|
||||
>
|
||||
<Text
|
||||
as="div"
|
||||
size="T200"
|
||||
priority="300"
|
||||
data-poll-content-label
|
||||
style={{
|
||||
fontWeight: 700,
|
||||
letterSpacing: '0.12em',
|
||||
textTransform: 'uppercase',
|
||||
marginBottom: config.space.S100,
|
||||
}}
|
||||
>
|
||||
<span aria-hidden>◉ </span>
|
||||
{headerLabel}
|
||||
</Text>
|
||||
<Text size="T400" style={{ fontWeight: 600 }}>
|
||||
{question}
|
||||
</Text>
|
||||
<Box direction="Column" gap="100">
|
||||
<Box alignItems="Center" gap="200" wrap="Wrap" data-poll-content-label>
|
||||
<Icon size="100" src={Icons.OrderList} style={{ opacity: 0.8 }} />
|
||||
<Text as="span" size="L400" style={{ fontWeight: 600 }}>
|
||||
Poll
|
||||
</Text>
|
||||
<Text as="span" size="T200" priority="300">
|
||||
·
|
||||
</Text>
|
||||
<Text as="span" size="T200" priority="300">
|
||||
{typeLabel}
|
||||
</Text>
|
||||
</Box>
|
||||
<Text size="T400" style={{ fontWeight: 600, overflowWrap: 'anywhere' }}>
|
||||
{question}
|
||||
</Text>
|
||||
</Box>
|
||||
<Box
|
||||
direction="Column"
|
||||
gap="100"
|
||||
style={{ marginTop: '2px' }}
|
||||
gap="200"
|
||||
role={isMultiple ? 'group' : 'radiogroup'}
|
||||
aria-label={question}
|
||||
onKeyDown={handleRadioKeyDown}
|
||||
@@ -316,20 +333,32 @@ export function PollContent({
|
||||
const text = answer.text;
|
||||
const selected = myVotes.has(id);
|
||||
const voteCount = counts.get(id) ?? 0;
|
||||
const pct = showResults && total > 0 ? Math.round((voteCount / total) * 100) : 0;
|
||||
const showBar = showResults && total > 0;
|
||||
const pct = showBar ? Math.round((voteCount / total) * 100) : 0;
|
||||
const isWinner = winners.has(id);
|
||||
const resultText = `${voteCount} ${voteCount === 1 ? 'vote' : 'votes'} · ${pct}%`;
|
||||
// Roving tabindex for the single-choice radiogroup; checkboxes stay tabbable.
|
||||
const tabIndex = isMultiple ? 0 : selected || (myVotes.size === 0 && i === 0) ? 0 : -1;
|
||||
let barColor = muted(40);
|
||||
if (isWinner) barColor = color.Success.Main;
|
||||
else if (selected) barColor = color.Primary.Main;
|
||||
let rowBorder = muted(22);
|
||||
if (isWinner) rowBorder = color.Success.Main;
|
||||
else if (selected) rowBorder = color.Primary.Main;
|
||||
const labelParts = [text];
|
||||
if (showBar) labelParts.push(resultText);
|
||||
if (isWinner) labelParts.push('winning answer');
|
||||
return (
|
||||
<React.Fragment key={id}>
|
||||
<button
|
||||
type="button"
|
||||
data-poll-answer
|
||||
data-selected={selected}
|
||||
data-winner={isWinner || undefined}
|
||||
role={isMultiple ? 'checkbox' : 'radio'}
|
||||
aria-checked={selected}
|
||||
aria-disabled={!canVote}
|
||||
aria-label={isWinner ? `${text}, winning answer` : undefined}
|
||||
aria-label={labelParts.join(', ')}
|
||||
aria-describedby={
|
||||
showVoters && canShowVoters && (voters.get(id)?.length ?? 0) > 0
|
||||
? `poll-voters-${eventId}-${id}`
|
||||
@@ -340,60 +369,36 @@ export function PollContent({
|
||||
style={{
|
||||
padding: `${config.space.S200} ${config.space.S300}`,
|
||||
borderRadius: config.radii.R300,
|
||||
background: selected ? color.Primary.Container : color.SurfaceVariant.Container,
|
||||
border: `${config.borderWidth.B300} solid ${
|
||||
isWinner
|
||||
? color.Success.Main
|
||||
: selected
|
||||
? color.Primary.Main
|
||||
: color.SurfaceVariant.ContainerLine
|
||||
}`,
|
||||
background: selected ? muted(8) : 'transparent',
|
||||
border: `${config.borderWidth.B300} solid ${rowBorder}`,
|
||||
lineHeight: 1.4,
|
||||
textAlign: 'left',
|
||||
cursor: canVote ? 'pointer' : 'default',
|
||||
color: 'inherit',
|
||||
font: 'inherit',
|
||||
display: 'flex',
|
||||
flexDirection: 'column',
|
||||
gap: config.space.S100,
|
||||
gap: config.space.S200,
|
||||
width: '100%',
|
||||
position: 'relative',
|
||||
overflow: 'hidden',
|
||||
transition: 'border-color 0.15s, background 0.15s',
|
||||
}}
|
||||
>
|
||||
{showResults && total > 0 && (
|
||||
<span
|
||||
aria-hidden
|
||||
style={{
|
||||
position: 'absolute',
|
||||
inset: 0,
|
||||
right: 'auto',
|
||||
width: `${pct}%`,
|
||||
background: selected
|
||||
? color.Primary.ContainerActive
|
||||
: color.SurfaceVariant.ContainerActive,
|
||||
pointerEvents: 'none',
|
||||
transition: 'width 0.3s ease',
|
||||
}}
|
||||
/>
|
||||
)}
|
||||
<span
|
||||
style={{
|
||||
display: 'flex',
|
||||
alignItems: 'center',
|
||||
gap: config.space.S200,
|
||||
position: 'relative',
|
||||
width: '100%',
|
||||
}}
|
||||
>
|
||||
<span
|
||||
aria-hidden
|
||||
style={{
|
||||
flexShrink: 0,
|
||||
width: toRem(14),
|
||||
height: toRem(14),
|
||||
border: `${config.borderWidth.B300} solid ${
|
||||
selected ? color.Primary.Main : color.Primary.ContainerLine
|
||||
}`,
|
||||
boxSizing: 'border-box',
|
||||
width: toRem(18),
|
||||
height: toRem(18),
|
||||
border: `2px solid ${selected ? color.Primary.Main : muted(55)}`,
|
||||
borderRadius: isMultiple ? config.radii.R300 : config.radii.Pill,
|
||||
background: selected ? color.Primary.Main : 'transparent',
|
||||
display: 'flex',
|
||||
@@ -405,29 +410,72 @@ export function PollContent({
|
||||
>
|
||||
{selected ? <Icon size="50" src={Icons.Check} /> : null}
|
||||
</span>
|
||||
<Text as="span" size="T300" style={{ flexGrow: 1 }}>
|
||||
<Text
|
||||
as="span"
|
||||
size="T300"
|
||||
style={{ flexGrow: 1, minWidth: 0, overflowWrap: 'anywhere' }}
|
||||
>
|
||||
{text}
|
||||
</Text>
|
||||
{isWinner && (
|
||||
<Icon
|
||||
size="50"
|
||||
src={Icons.Check}
|
||||
style={{ flexShrink: 0, color: color.Success.Main }}
|
||||
/>
|
||||
<Text
|
||||
as="span"
|
||||
size="T200"
|
||||
style={{
|
||||
flexShrink: 0,
|
||||
display: 'inline-flex',
|
||||
alignItems: 'center',
|
||||
gap: config.space.S100,
|
||||
color: color.Success.Main,
|
||||
fontWeight: 600,
|
||||
}}
|
||||
>
|
||||
<Icon size="50" src={Icons.Star} filled />
|
||||
Winner
|
||||
</Text>
|
||||
)}
|
||||
{showResults && total > 0 && (
|
||||
<Text as="span" size="T200" priority="300" style={{ flexShrink: 0 }}>
|
||||
{pct}%
|
||||
{showBar && (
|
||||
<Text
|
||||
as="span"
|
||||
size="T200"
|
||||
priority="300"
|
||||
style={{ flexShrink: 0, fontVariantNumeric: 'tabular-nums' }}
|
||||
>
|
||||
{resultText}
|
||||
</Text>
|
||||
)}
|
||||
</span>
|
||||
{showBar && (
|
||||
<span
|
||||
aria-hidden
|
||||
style={{
|
||||
display: 'block',
|
||||
width: '100%',
|
||||
height: toRem(6),
|
||||
borderRadius: config.radii.Pill,
|
||||
background: muted(12),
|
||||
overflow: 'hidden',
|
||||
}}
|
||||
>
|
||||
<span
|
||||
style={{
|
||||
display: 'block',
|
||||
height: '100%',
|
||||
width: `${pct}%`,
|
||||
borderRadius: config.radii.Pill,
|
||||
background: barColor,
|
||||
transition: 'width 0.3s ease',
|
||||
}}
|
||||
/>
|
||||
</span>
|
||||
)}
|
||||
</button>
|
||||
{showVoters && canShowVoters && (voters.get(id)?.length ?? 0) > 0 && (
|
||||
<Text
|
||||
id={`poll-voters-${eventId}-${id}`}
|
||||
size="T200"
|
||||
priority="300"
|
||||
style={{ padding: `0 ${config.space.S300} ${config.space.S100}` }}
|
||||
style={{ padding: `0 ${config.space.S300}`, marginTop: `-${config.space.S100}` }}
|
||||
>
|
||||
{`Voted by ${(voters.get(id) ?? []).map((s) => getMemberName(room, s)).join(', ')}`}
|
||||
</Text>
|
||||
@@ -436,48 +484,56 @@ export function PollContent({
|
||||
);
|
||||
})}
|
||||
</Box>
|
||||
{canShowVoters && (
|
||||
<Box>
|
||||
<Chip
|
||||
variant={showVoters ? 'Primary' : 'SurfaceVariant'}
|
||||
radii="Pill"
|
||||
aria-pressed={showVoters}
|
||||
onClick={() => setShowVoters((v) => !v)}
|
||||
before={<Icon size="50" src={Icons.User} />}
|
||||
>
|
||||
<Text size="T200">{showVoters ? 'Hide voters' : 'Show who voted'}</Text>
|
||||
</Chip>
|
||||
</Box>
|
||||
)}
|
||||
<Box alignItems="Center" justifyContent="SpaceBetween" gap="200">
|
||||
<Text size="T200" priority="300" style={{ minWidth: 0 }}>
|
||||
<i>{footerNote}</i>
|
||||
<Box alignItems="Center" justifyContent="SpaceBetween" gap="200" wrap="Wrap">
|
||||
<Text size="T200" priority="300" style={{ minWidth: 0, flex: '1 1 12rem' }}>
|
||||
{footerNote}
|
||||
</Text>
|
||||
{canEnd &&
|
||||
(confirmEnd ? (
|
||||
<Box gap="100" shrink="No" alignItems="Center">
|
||||
<Chip
|
||||
variant="Critical"
|
||||
radii="Pill"
|
||||
aria-disabled={ending}
|
||||
onClick={ending ? undefined : handleEndPoll}
|
||||
>
|
||||
<Text size="T200">{ending ? 'Ending…' : 'End poll'}</Text>
|
||||
</Chip>
|
||||
<Chip variant="Secondary" radii="Pill" onClick={() => setConfirmEnd(false)}>
|
||||
<Text size="T200">Cancel</Text>
|
||||
</Chip>
|
||||
</Box>
|
||||
) : (
|
||||
<Box gap="100" shrink="No" alignItems="Center" wrap="Wrap">
|
||||
{canShowVoters && (
|
||||
<Chip
|
||||
variant="SurfaceVariant"
|
||||
variant={showVoters ? 'Primary' : 'SurfaceVariant'}
|
||||
radii="Pill"
|
||||
onClick={() => setConfirmEnd(true)}
|
||||
before={<Icon size="50" src={Icons.Cross} />}
|
||||
aria-pressed={showVoters}
|
||||
onClick={() => setShowVoters((v) => !v)}
|
||||
before={<Icon size="50" src={Icons.User} />}
|
||||
>
|
||||
<Text size="T200">End poll</Text>
|
||||
<Text size="T200" style={{ whiteSpace: 'nowrap' }}>
|
||||
{showVoters ? 'Hide voters' : 'Who voted'}
|
||||
</Text>
|
||||
</Chip>
|
||||
))}
|
||||
)}
|
||||
{canEnd &&
|
||||
(confirmEnd ? (
|
||||
<>
|
||||
<Chip
|
||||
variant="Critical"
|
||||
radii="Pill"
|
||||
aria-disabled={ending}
|
||||
onClick={ending ? undefined : handleEndPoll}
|
||||
>
|
||||
<Text size="T200" style={{ whiteSpace: 'nowrap' }}>
|
||||
{ending ? 'Ending…' : 'End poll'}
|
||||
</Text>
|
||||
</Chip>
|
||||
<Chip variant="Secondary" radii="Pill" onClick={() => setConfirmEnd(false)}>
|
||||
<Text size="T200" style={{ whiteSpace: 'nowrap' }}>
|
||||
Cancel
|
||||
</Text>
|
||||
</Chip>
|
||||
</>
|
||||
) : (
|
||||
<Chip
|
||||
variant="SurfaceVariant"
|
||||
radii="Pill"
|
||||
onClick={() => setConfirmEnd(true)}
|
||||
before={<Icon size="50" src={Icons.Cross} />}
|
||||
>
|
||||
<Text size="T200" style={{ whiteSpace: 'nowrap' }}>
|
||||
End poll
|
||||
</Text>
|
||||
</Chip>
|
||||
))}
|
||||
</Box>
|
||||
</Box>
|
||||
</Box>
|
||||
);
|
||||
|
||||
@@ -23,6 +23,7 @@ import { CallMemberRenderer } from './CallMemberCard';
|
||||
import * as css from './styles.css';
|
||||
import { CallControls } from './CallControls';
|
||||
import { useLivekitSupport } from '../../hooks/useLivekitSupport';
|
||||
import { CallsUnavailableMessage } from './CallsUnavailable';
|
||||
import { webRTCSupported } from '../../utils/rtc';
|
||||
|
||||
function LivekitServerMissingMessage() {
|
||||
@@ -33,25 +34,19 @@ function LivekitServerMissingMessage() {
|
||||
);
|
||||
}
|
||||
|
||||
function WebRTCMissingError() {
|
||||
return (
|
||||
<Text style={{ margin: 'auto', color: color.Critical.Main }} size="L400" align="Center">
|
||||
Your browser does not support WebRTC, which is required for calling.
|
||||
</Text>
|
||||
);
|
||||
}
|
||||
|
||||
function JoinMessage({
|
||||
roomId,
|
||||
hasParticipant,
|
||||
livekitSupported,
|
||||
rtcSupported,
|
||||
}: {
|
||||
roomId: string;
|
||||
hasParticipant?: boolean;
|
||||
livekitSupported?: boolean;
|
||||
rtcSupported?: boolean;
|
||||
}) {
|
||||
if (rtcSupported === false) {
|
||||
return <WebRTCMissingError />;
|
||||
return <CallsUnavailableMessage roomId={roomId} />;
|
||||
}
|
||||
|
||||
if (livekitSupported === false) {
|
||||
@@ -144,6 +139,7 @@ function CallPrescreen() {
|
||||
)}
|
||||
{!inOtherCall && hasPermission && !channelFull && (
|
||||
<JoinMessage
|
||||
roomId={room.roomId}
|
||||
hasParticipant={hasParticipant}
|
||||
livekitSupported={livekitSupported}
|
||||
rtcSupported={rtcSupported}
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
import React, { useMemo } from 'react';
|
||||
import { Box, Button, Icon, Icons, Text, color } from 'folds';
|
||||
import { useClientConfig } from '../../hooks/useClientConfig';
|
||||
import { isTauri } from '../../hooks/useTauri';
|
||||
import { webRTCSupported } from '../../utils/rtc';
|
||||
import { getCallInBrowserUrl, resolveWebAppUrl } from '../../utils/callInBrowser';
|
||||
|
||||
/**
|
||||
* [cinny-desktop: Linux calls] The desktop app on Linux runs on WebKitGTK,
|
||||
* which ships without WebRTC (disabled in 2.54; a libwebrtc backend is due
|
||||
* around 2.56). Where calls can't work here, send the user to the room in the
|
||||
* web app instead of a dead end. Only in the desktop app, and only when
|
||||
* config.json sets `webAppUrl`.
|
||||
*/
|
||||
export const useCallInBrowserUrl = (roomId: string): string | undefined => {
|
||||
const { webAppUrl } = useClientConfig();
|
||||
return useMemo(
|
||||
() =>
|
||||
isTauri() && !webRTCSupported()
|
||||
? getCallInBrowserUrl(resolveWebAppUrl(webAppUrl), roomId)
|
||||
: undefined,
|
||||
[webAppUrl, roomId],
|
||||
);
|
||||
};
|
||||
|
||||
/** Opens through the desktop's new-window handler → the system browser. */
|
||||
export const openCallInBrowser = (url: string): void => {
|
||||
window.open(url, '_blank', 'noopener,noreferrer');
|
||||
};
|
||||
|
||||
const desktopUnavailableText = (): string =>
|
||||
typeof navigator !== 'undefined' && /Linux/i.test(navigator.userAgent)
|
||||
? 'Calls aren’t available in the desktop app on Linux yet: its web engine has no WebRTC.'
|
||||
: 'Calls aren’t available in this desktop app: its web engine has no WebRTC.';
|
||||
|
||||
type CallsUnavailableMessageProps = {
|
||||
roomId: string;
|
||||
/** Button label, e.g. "Answer in browser" for an incoming call. */
|
||||
actionLabel?: string;
|
||||
};
|
||||
|
||||
export function CallsUnavailableMessage({
|
||||
roomId,
|
||||
actionLabel = 'Open in browser',
|
||||
}: CallsUnavailableMessageProps) {
|
||||
const url = useCallInBrowserUrl(roomId);
|
||||
|
||||
if (!isTauri()) {
|
||||
return (
|
||||
<Text style={{ margin: 'auto', color: color.Critical.Main }} size="L400" align="Center">
|
||||
Your browser does not support WebRTC, which is required for calling.
|
||||
</Text>
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
<Box direction="Column" alignItems="Center" gap="200" style={{ margin: 'auto' }}>
|
||||
<Text style={{ color: color.Warning.Main }} size="L400" align="Center">
|
||||
{desktopUnavailableText()}
|
||||
{url ? ' You can join from the web app in your browser.' : ''}
|
||||
</Text>
|
||||
{url && (
|
||||
<Button
|
||||
size="300"
|
||||
variant="Secondary"
|
||||
fill="Soft"
|
||||
radii="300"
|
||||
before={<Icon size="100" src={Icons.External} />}
|
||||
onClick={() => openCallInBrowser(url)}
|
||||
>
|
||||
<Text size="B300">{actionLabel}</Text>
|
||||
</Button>
|
||||
)}
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,268 @@
|
||||
import { useSetAtom } from 'jotai';
|
||||
import { useEffect } from 'react';
|
||||
import {
|
||||
ClientEvent,
|
||||
ClientEventHandlerMap,
|
||||
ConnectionError,
|
||||
EventStatus,
|
||||
KnownMembership,
|
||||
MatrixClient,
|
||||
MatrixError,
|
||||
MatrixEvent,
|
||||
Room,
|
||||
RoomEvent,
|
||||
RoomEventHandlerMap,
|
||||
SyncState,
|
||||
} from 'matrix-js-sdk';
|
||||
import { useMatrixClient } from '../../hooks/useMatrixClient';
|
||||
import { sendOfflineAtom } from '../../state/sendOffline';
|
||||
import {
|
||||
OUTBOX_MAX_AUTO_RETRIES,
|
||||
OutboxEntry,
|
||||
isRetryableSendError,
|
||||
loadOutbox,
|
||||
outboxRetryDelayMs,
|
||||
planRestore,
|
||||
saveOutbox,
|
||||
shouldKeepInOutbox,
|
||||
withEntry,
|
||||
withoutEntry,
|
||||
} from '../../utils/outbox';
|
||||
|
||||
const PENDING: ReadonlySet<EventStatus | null> = new Set([
|
||||
EventStatus.SENDING,
|
||||
EventStatus.ENCRYPTING,
|
||||
EventStatus.QUEUED,
|
||||
EventStatus.NOT_SENT,
|
||||
]);
|
||||
const ONLINE: ReadonlySet<SyncState | null> = new Set([
|
||||
SyncState.Prepared,
|
||||
SyncState.Syncing,
|
||||
SyncState.Catchup,
|
||||
]);
|
||||
const OFFLINE: ReadonlySet<SyncState | null> = new Set([SyncState.Reconnecting, SyncState.Error]);
|
||||
|
||||
/** The server already has it: its transaction id came back down /sync. */
|
||||
const isDelivered = (room: Room, txnId: string): boolean => {
|
||||
const hasTxn = (events: MatrixEvent[]) =>
|
||||
events.some((e) => e.getUnsigned().transaction_id === txnId);
|
||||
return (
|
||||
hasTxn(room.getLiveTimeline().getEvents()) ||
|
||||
room.getThreads().some((t) => hasTxn(t.liveTimeline.getEvents()))
|
||||
);
|
||||
};
|
||||
|
||||
type OutboxSession = {
|
||||
/** Own pending events of this session, by txnId. */
|
||||
live: Map<string, { event: MatrixEvent; room: Room }>;
|
||||
autoRetries: Map<string, number>;
|
||||
restored: boolean;
|
||||
retrying: boolean;
|
||||
};
|
||||
|
||||
// Per client, not per mount: a remount must neither restore twice nor forget
|
||||
// the events it is tracking.
|
||||
const sessions = new WeakMap<MatrixClient, OutboxSession>();
|
||||
const getSession = (mx: MatrixClient): OutboxSession => {
|
||||
let session = sessions.get(mx);
|
||||
if (!session) {
|
||||
session = { live: new Map(), autoRetries: new Map(), restored: false, retrying: false };
|
||||
sessions.set(mx, session);
|
||||
}
|
||||
return session;
|
||||
};
|
||||
|
||||
/**
|
||||
* [Gitea #112] Offline outbox (see utils/outbox.ts): mirrors own message sends
|
||||
* into localStorage until the server confirms them, puts unsent ones back
|
||||
* after a reload, and re-sends network failures when the connection returns.
|
||||
*/
|
||||
export function OutboxFeature() {
|
||||
const mx = useMatrixClient();
|
||||
const setOffline = useSetAtom(sendOfflineAtom);
|
||||
|
||||
useEffect(() => {
|
||||
const userId = mx.getSafeUserId();
|
||||
let entries = loadOutbox(userId);
|
||||
const session = getSession(mx);
|
||||
const { live, autoRetries } = session;
|
||||
let disposed = false;
|
||||
let offlineNow = false;
|
||||
const timers = new Set<ReturnType<typeof setTimeout>>();
|
||||
|
||||
const isOffline = () =>
|
||||
OFFLINE.has(mx.getSyncState()) ||
|
||||
(typeof navigator !== 'undefined' && navigator.onLine === false);
|
||||
|
||||
const persist = (next: OutboxEntry[]) => {
|
||||
if (next === entries) return;
|
||||
entries = next;
|
||||
saveOutbox(userId, entries);
|
||||
};
|
||||
|
||||
/**
|
||||
* A network failure while we think we're online (a blip neither sync nor
|
||||
* the browser noticed): try again shortly, backing off. Real outages are
|
||||
* handled by the reconnect / back-online triggers below.
|
||||
*/
|
||||
const scheduleBlipRetry = (event: MatrixEvent) => {
|
||||
const attempts = autoRetries.get(event.getTxnId() ?? '') ?? 0;
|
||||
if (!isRetryableSendError(event.error) || attempts >= OUTBOX_MAX_AUTO_RETRIES || isOffline())
|
||||
return;
|
||||
const timer = setTimeout(() => {
|
||||
timers.delete(timer);
|
||||
retryQueued();
|
||||
}, outboxRetryDelayMs(attempts));
|
||||
timers.add(timer);
|
||||
};
|
||||
|
||||
const onLocalEcho: RoomEventHandlerMap[RoomEvent.LocalEchoUpdated] = (event, room) => {
|
||||
const txnId = event.getTxnId();
|
||||
if (!txnId || event.getSender() !== userId) return;
|
||||
if (PENDING.has(event.status)) {
|
||||
if (!shouldKeepInOutbox(event.getType(), event.getContent())) return;
|
||||
live.set(txnId, { event, room });
|
||||
if (event.status === EventStatus.NOT_SENT) scheduleBlipRetry(event);
|
||||
persist(
|
||||
withEntry(entries, {
|
||||
txnId,
|
||||
roomId: room.roomId,
|
||||
threadId: event.threadRootId ?? null,
|
||||
type: event.getType(),
|
||||
content: event.getContent(),
|
||||
ts: event.getTs(),
|
||||
}),
|
||||
);
|
||||
return;
|
||||
}
|
||||
// SENT, CANCELLED, or the remote echo replaced it (status null).
|
||||
live.delete(txnId);
|
||||
autoRetries.delete(txnId);
|
||||
persist(withoutEntry(entries, txnId));
|
||||
};
|
||||
|
||||
/** Re-send network failures, oldest first; a room stops at its first failure. */
|
||||
const retryQueued = async () => {
|
||||
if (session.retrying || disposed) return;
|
||||
session.retrying = true;
|
||||
try {
|
||||
const byRoom = new Map<Room, MatrixEvent[]>();
|
||||
Array.from(live.values())
|
||||
.filter(
|
||||
({ event }) =>
|
||||
event.status === EventStatus.NOT_SENT &&
|
||||
isRetryableSendError(event.error) &&
|
||||
(autoRetries.get(event.getTxnId() ?? '') ?? 0) < OUTBOX_MAX_AUTO_RETRIES,
|
||||
)
|
||||
.sort((a, b) => a.event.getTs() - b.event.getTs())
|
||||
.forEach(({ event, room }) => {
|
||||
byRoom.set(room, [...(byRoom.get(room) ?? []), event]);
|
||||
});
|
||||
await Promise.all(
|
||||
Array.from(byRoom.entries()).map(async ([room, events]) => {
|
||||
for (const event of events) {
|
||||
if (disposed || event.status !== EventStatus.NOT_SENT) continue;
|
||||
const txnId = event.getTxnId() ?? '';
|
||||
autoRetries.set(txnId, (autoRetries.get(txnId) ?? 0) + 1);
|
||||
try {
|
||||
// eslint-disable-next-line no-await-in-loop
|
||||
await mx.resendEvent(event, room);
|
||||
} catch (e) {
|
||||
// Still offline: keep the rest of this room in order for the next try.
|
||||
if (isRetryableSendError(e)) break;
|
||||
}
|
||||
}
|
||||
}),
|
||||
);
|
||||
} finally {
|
||||
session.retrying = false;
|
||||
}
|
||||
};
|
||||
|
||||
const restore = () => {
|
||||
if (session.restored) return;
|
||||
session.restored = true;
|
||||
const plan = planRestore(
|
||||
entries,
|
||||
Date.now(),
|
||||
(roomId) => mx.getRoom(roomId)?.getMyMembership() === KnownMembership.Join,
|
||||
(entry) => {
|
||||
const room = mx.getRoom(entry.roomId);
|
||||
return !!room && isDelivered(room, entry.txnId);
|
||||
},
|
||||
);
|
||||
plan.drop.forEach((entry) => persist(withoutEntry(entries, entry.txnId)));
|
||||
plan.restore.forEach((entry) => {
|
||||
const room = mx.getRoom(entry.roomId);
|
||||
if (!room || live.has(entry.txnId)) return;
|
||||
// Same shape as the SDK's own local echo (client.sendCompleteEvent).
|
||||
const event = new MatrixEvent({
|
||||
type: entry.type,
|
||||
content: entry.content,
|
||||
event_id: `~${entry.roomId}:${entry.txnId}`,
|
||||
sender: userId,
|
||||
room_id: entry.roomId,
|
||||
origin_server_ts: entry.ts,
|
||||
});
|
||||
const thread = entry.threadId ? room.getThread(entry.threadId) : undefined;
|
||||
if (thread) event.setThread(thread);
|
||||
event.setTxnId(entry.txnId);
|
||||
event.setStatus(EventStatus.NOT_SENT);
|
||||
if (plan.autoSend.has(entry.txnId)) {
|
||||
// Recent: treat like a send that lost the network (shown as Queued
|
||||
// while offline, re-sent below and on reconnect).
|
||||
// (The SDK types `error` as MatrixError but stores any send error there.)
|
||||
event.error = new ConnectionError(
|
||||
'not sent before the app was closed',
|
||||
) as unknown as MatrixError;
|
||||
} else {
|
||||
// Old: back as "Failed to send"; the user decides (Retry / Cancel).
|
||||
autoRetries.set(entry.txnId, OUTBOX_MAX_AUTO_RETRIES);
|
||||
}
|
||||
try {
|
||||
room.addPendingEvent(event, entry.txnId); // emits LocalEchoUpdated → `live`
|
||||
} catch {
|
||||
// Already pending under this txnId: nothing to restore.
|
||||
}
|
||||
});
|
||||
if (!isOffline()) retryQueued();
|
||||
};
|
||||
|
||||
const updateOffline = () => {
|
||||
const offline = isOffline();
|
||||
// Back online (sync recovered or the browser says so): send what's queued.
|
||||
if (offlineNow && !offline && session.restored) retryQueued();
|
||||
offlineNow = offline;
|
||||
setOffline(offline);
|
||||
};
|
||||
|
||||
const onSync: ClientEventHandlerMap[ClientEvent.Sync] = (state, prevState) => {
|
||||
updateOffline();
|
||||
if (!ONLINE.has(state)) return;
|
||||
if (!session.restored) {
|
||||
restore();
|
||||
return;
|
||||
}
|
||||
if (OFFLINE.has(prevState) || prevState === SyncState.Catchup) retryQueued();
|
||||
};
|
||||
const onBrowserOnline = () => updateOffline();
|
||||
|
||||
mx.on(RoomEvent.LocalEchoUpdated, onLocalEcho);
|
||||
mx.on(ClientEvent.Sync, onSync);
|
||||
window.addEventListener('online', onBrowserOnline);
|
||||
window.addEventListener('offline', onBrowserOnline);
|
||||
updateOffline();
|
||||
if (ONLINE.has(mx.getSyncState())) restore();
|
||||
|
||||
return () => {
|
||||
disposed = true;
|
||||
timers.forEach((t) => clearTimeout(t));
|
||||
mx.off(RoomEvent.LocalEchoUpdated, onLocalEcho);
|
||||
mx.off(ClientEvent.Sync, onSync);
|
||||
window.removeEventListener('online', onBrowserOnline);
|
||||
window.removeEventListener('offline', onBrowserOnline);
|
||||
};
|
||||
}, [mx, setOffline]);
|
||||
|
||||
return null;
|
||||
}
|
||||
@@ -80,6 +80,7 @@ import { widgetsPanelAtom } from '../../state/widgetsPanel';
|
||||
import { mobileMembersPanelAtom } from '../../state/mobileMembersPanel';
|
||||
import { threadsListAtom } from '../../state/threadsList';
|
||||
import { usePendingKnocks } from '../../hooks/usePendingKnocks';
|
||||
import { openCallInBrowser, useCallInBrowserUrl } from '../call/CallsUnavailable';
|
||||
import { bookmarksPanelAtom } from '../../state/bookmarksPanel';
|
||||
|
||||
type RoomMenuProps = {
|
||||
@@ -465,6 +466,36 @@ function CallRulesChip({ room }: { room: Room }) {
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* [cinny-desktop: Linux calls] Stand-in for CallButton where this app can't
|
||||
* make calls (desktop on WebKitGTK): opens the room in the web app instead.
|
||||
*/
|
||||
function CallInBrowserButton({ url }: { url: string }) {
|
||||
return (
|
||||
<TooltipProvider
|
||||
position="Bottom"
|
||||
offset={4}
|
||||
tooltip={
|
||||
<Tooltip>
|
||||
<Text>Call in your browser (this desktop app can’t make calls here)</Text>
|
||||
</Tooltip>
|
||||
}
|
||||
>
|
||||
{(triggerRef) => (
|
||||
<IconButton
|
||||
variant="Surface"
|
||||
fill="None"
|
||||
ref={triggerRef}
|
||||
aria-label="Start call in browser"
|
||||
onClick={() => openCallInBrowser(url)}
|
||||
>
|
||||
<Icon size="400" src={Icons.VideoCamera} />
|
||||
</IconButton>
|
||||
)}
|
||||
</TooltipProvider>
|
||||
);
|
||||
}
|
||||
|
||||
function CallButton() {
|
||||
const room = useRoom();
|
||||
const direct = useIsDirectRoom();
|
||||
@@ -555,6 +586,7 @@ export function RoomViewHeader({ callView }: { callView?: boolean }) {
|
||||
);
|
||||
const livekitSupported = useLivekitSupport();
|
||||
const rtcSupported = webRTCSupported();
|
||||
const callInBrowserUrl = useCallInBrowserUrl(room.roomId);
|
||||
|
||||
const [menuAnchor, setMenuAnchor] = useState<RectCords>();
|
||||
const [pinMenuAnchor, setPinMenuAnchor] = useState<RectCords>();
|
||||
@@ -782,11 +814,16 @@ export function RoomViewHeader({ callView }: { callView?: boolean }) {
|
||||
{screenSize === ScreenSize.Desktop && <CallRulesChip room={room} />}
|
||||
{!room.isCallRoom() &&
|
||||
livekitSupported &&
|
||||
rtcSupported &&
|
||||
(rtcSupported || callInBrowserUrl) &&
|
||||
hasCallPermission &&
|
||||
(direct ||
|
||||
(room.getJoinRule() === 'invite' &&
|
||||
getStateEvents(room, StateEvent.SpaceParent).length === 0)) && <CallButton />}
|
||||
getStateEvents(room, StateEvent.SpaceParent).length === 0)) &&
|
||||
(rtcSupported ? (
|
||||
<CallButton />
|
||||
) : (
|
||||
callInBrowserUrl && <CallInBrowserButton url={callInBrowserUrl} />
|
||||
))}
|
||||
{screenSize === ScreenSize.Desktop && (
|
||||
<TooltipProvider
|
||||
position="Bottom"
|
||||
|
||||
@@ -26,6 +26,7 @@ import {
|
||||
config,
|
||||
} from 'folds';
|
||||
import React, {
|
||||
CSSProperties,
|
||||
FormEventHandler,
|
||||
MouseEventHandler,
|
||||
ReactNode,
|
||||
@@ -38,7 +39,7 @@ import { useHover, useFocusWithin } from 'react-aria';
|
||||
import { MatrixEvent, Room, EventStatus } from 'matrix-js-sdk';
|
||||
import { Relations } from 'matrix-js-sdk/lib/models/relations';
|
||||
import classNames from 'classnames';
|
||||
import { useAtom } from 'jotai';
|
||||
import { useAtom, useAtomValue } from 'jotai';
|
||||
import { RoomPinnedEventsEventContent } from 'matrix-js-sdk/lib/types';
|
||||
import {
|
||||
AvatarBase,
|
||||
@@ -83,8 +84,6 @@ import { copyToClipboard } from '../../../utils/dom';
|
||||
import { stopPropagation } from '../../../utils/keyboard';
|
||||
import { getMatrixToRoomEvent } from '../../../plugins/matrix-to';
|
||||
import { getLotusRoomPermalink } from '../../../plugins/lotus-permalink';
|
||||
import { getOriginBaseUrl } from '../../../pages/pathUtils';
|
||||
import { useClientConfig } from '../../../hooks/useClientConfig';
|
||||
import { getViaServers } from '../../../plugins/via-servers';
|
||||
import { useMediaAuthentication } from '../../../hooks/useMediaAuthentication';
|
||||
import { useRoomPinnedEvents } from '../../../hooks/useRoomPinnedEvents';
|
||||
@@ -98,28 +97,41 @@ import { useLongPress } from '../../../hooks/useLongPress';
|
||||
import { ActionSheet } from '../../../components/action-sheet';
|
||||
import { useBookmarks } from '../../../hooks/useBookmarks';
|
||||
import { PresenceRingAvatar } from '../../../components/presence';
|
||||
import { useLotusShareBase } from '../../../hooks/useLotusLinkBase';
|
||||
import { AvatarDecoration } from '../../../components/avatar-decoration/AvatarDecoration';
|
||||
import { sendOfflineAtom } from '../../../state/sendOffline';
|
||||
import { isRetryableSendError } from '../../../utils/outbox';
|
||||
|
||||
// Delivery status indicator for own messages
|
||||
function DeliveryStatus({
|
||||
status,
|
||||
mEvent,
|
||||
room,
|
||||
lotusTerminal,
|
||||
}: {
|
||||
status: string | null;
|
||||
mEvent: MatrixEvent;
|
||||
room: Room;
|
||||
lotusTerminal: boolean;
|
||||
}) {
|
||||
const mx = useMatrixClient();
|
||||
const offline = useAtomValue(sendOfflineAtom);
|
||||
const { status } = mEvent;
|
||||
if (status === null) return null; // confirmed by server — read receipts take over
|
||||
let iconSrc: IconSrc;
|
||||
let label: string;
|
||||
let colorStyle: string;
|
||||
const isSending = status === EventStatus.SENDING || status === EventStatus.ENCRYPTING;
|
||||
if (status === EventStatus.NOT_SENT || status === EventStatus.CANCELLED) {
|
||||
// [Gitea #112] A network failure while offline is queued, not failed: the
|
||||
// outbox sends it again when the connection is back.
|
||||
const queued = status === EventStatus.NOT_SENT && offline && isRetryableSendError(mEvent.error);
|
||||
const failed = !queued && (status === EventStatus.NOT_SENT || status === EventStatus.CANCELLED);
|
||||
if (failed) {
|
||||
iconSrc = Icons.Cross;
|
||||
label = 'Failed to send';
|
||||
label = status === EventStatus.NOT_SENT ? 'Failed to send. Click to retry' : 'Failed to send';
|
||||
colorStyle = lotusTerminal ? 'var(--lt-accent-red)' : color.Critical.Main;
|
||||
} else if (status === EventStatus.QUEUED || isSending) {
|
||||
iconSrc = Icons.Send;
|
||||
label = isSending ? 'Sending...' : 'Queued';
|
||||
} else if (queued || status === EventStatus.QUEUED || isSending) {
|
||||
iconSrc = queued ? Icons.RecentClock : Icons.Send;
|
||||
if (queued) label = "Queued. Will send when you're back online";
|
||||
else label = isSending ? 'Sending...' : 'Queued';
|
||||
colorStyle = lotusTerminal
|
||||
? 'color-mix(in srgb, var(--lt-accent-cyan) 60%, transparent)'
|
||||
: color.Secondary.Main;
|
||||
@@ -130,27 +142,49 @@ function DeliveryStatus({
|
||||
? 'color-mix(in srgb, var(--lt-accent-cyan) 70%, transparent)'
|
||||
: color.Secondary.Main;
|
||||
}
|
||||
const retryable = failed && status === EventStatus.NOT_SENT;
|
||||
const handleRetry: MouseEventHandler<HTMLButtonElement> = (evt) => {
|
||||
evt.stopPropagation();
|
||||
if (mEvent.status === EventStatus.NOT_SENT) mx.resendEvent(mEvent, room).catch(() => undefined);
|
||||
};
|
||||
const style: CSSProperties = {
|
||||
display: 'inline-flex',
|
||||
alignItems: 'center',
|
||||
marginTop: '2px',
|
||||
lineHeight: 1,
|
||||
color: colorStyle,
|
||||
opacity: 0.85,
|
||||
userSelect: 'none',
|
||||
...(lotusTerminal && failed ? { textShadow: 'var(--lt-glow-red)' } : {}),
|
||||
};
|
||||
const icon = (
|
||||
<span className={isSending ? SendingSpinClass : undefined}>
|
||||
<Icon size="100" src={iconSrc} />
|
||||
</span>
|
||||
);
|
||||
if (retryable) {
|
||||
return (
|
||||
<button
|
||||
type="button"
|
||||
onClick={handleRetry}
|
||||
aria-label={label}
|
||||
title={label}
|
||||
style={{
|
||||
...style,
|
||||
background: 'none',
|
||||
border: 'none',
|
||||
padding: 0,
|
||||
cursor: 'pointer',
|
||||
font: 'inherit',
|
||||
}}
|
||||
>
|
||||
{icon}
|
||||
</button>
|
||||
);
|
||||
}
|
||||
return (
|
||||
<Box
|
||||
as="span"
|
||||
aria-label={label}
|
||||
title={label}
|
||||
style={{
|
||||
display: 'inline-flex',
|
||||
alignItems: 'center',
|
||||
marginTop: '2px',
|
||||
lineHeight: 1,
|
||||
color: colorStyle,
|
||||
opacity: 0.85,
|
||||
userSelect: 'none',
|
||||
...(lotusTerminal && status === EventStatus.NOT_SENT
|
||||
? { textShadow: 'var(--lt-glow-red)' }
|
||||
: {}),
|
||||
}}
|
||||
>
|
||||
<span className={isSending ? SendingSpinClass : undefined}>
|
||||
<Icon size="100" src={iconSrc} />
|
||||
</span>
|
||||
<Box as="span" aria-label={label} title={label} style={style}>
|
||||
{icon}
|
||||
</Box>
|
||||
);
|
||||
}
|
||||
@@ -460,18 +494,11 @@ export const MessageCopyLotusLinkItem = as<
|
||||
onClose?: () => void;
|
||||
}
|
||||
>(({ room, mEvent, onClose, ...props }, ref) => {
|
||||
const { hashRouter } = useClientConfig();
|
||||
const lotusBase = useLotusShareBase();
|
||||
const handleCopy = () => {
|
||||
const eventId = mEvent.getId();
|
||||
if (!eventId) return;
|
||||
copyToClipboard(
|
||||
getLotusRoomPermalink(
|
||||
getOriginBaseUrl(hashRouter),
|
||||
room.roomId,
|
||||
eventId,
|
||||
getViaServers(room),
|
||||
),
|
||||
);
|
||||
copyToClipboard(getLotusRoomPermalink(lotusBase, room.roomId, eventId, getViaServers(room)));
|
||||
onClose?.();
|
||||
};
|
||||
|
||||
@@ -1110,7 +1137,7 @@ export const Message = React.memo(
|
||||
/>
|
||||
)}
|
||||
{isMine && !mEvent.isState() && readReceiptUsers.length === 0 && (
|
||||
<DeliveryStatus status={mEvent.status} lotusTerminal={!!lotusTerminal} />
|
||||
<DeliveryStatus mEvent={mEvent} room={room} lotusTerminal={!!lotusTerminal} />
|
||||
)}
|
||||
</Box>
|
||||
);
|
||||
|
||||
@@ -33,6 +33,8 @@ import { Badge, Box, Chip, Icon, Icons, Line, Scroll, Spinner, Text, color, conf
|
||||
import classNames from 'classnames';
|
||||
import { Opts as LinkifyOpts } from 'linkifyjs';
|
||||
import { isKeyHotkey } from 'is-hotkey';
|
||||
import { isRetryableSendError } from '../../../utils/outbox';
|
||||
import { sendOfflineAtom } from '../../../state/sendOffline';
|
||||
import { eventWithShortcode, factoryEventSentBy } from '../../../utils/matrix';
|
||||
import { useMatrixClient } from '../../../hooks/useMatrixClient';
|
||||
import { useVirtualPaginator, ItemRange } from '../../../hooks/useVirtualPaginator';
|
||||
@@ -253,6 +255,7 @@ export type ThreadTimelineProps = {
|
||||
|
||||
export function ThreadTimeline({ room, thread, editor }: ThreadTimelineProps) {
|
||||
const mx = useMatrixClient();
|
||||
const sendOffline = useAtomValue(sendOfflineAtom);
|
||||
const alive = useAlive();
|
||||
const useAuthentication = useMediaAuthentication();
|
||||
|
||||
@@ -992,8 +995,12 @@ export function ThreadTimeline({ room, thread, editor }: ThreadTimelineProps) {
|
||||
const showEmptyReplies = ready && thread.length === 0;
|
||||
|
||||
const renderPendingEvent = (mEvent: MatrixEvent) => {
|
||||
// [Gitea #112] Network failures while offline are queued, not failed.
|
||||
const queued =
|
||||
mEvent.status === EventStatus.NOT_SENT && sendOffline && isRetryableSendError(mEvent.error);
|
||||
const failed =
|
||||
mEvent.status === EventStatus.NOT_SENT || mEvent.status === EventStatus.CANCELLED;
|
||||
!queued &&
|
||||
(mEvent.status === EventStatus.NOT_SENT || mEvent.status === EventStatus.CANCELLED);
|
||||
return (
|
||||
<div
|
||||
key={mEvent.getId() ?? mEvent.getTxnId()}
|
||||
@@ -1007,6 +1014,13 @@ export function ThreadTimeline({ room, thread, editor }: ThreadTimelineProps) {
|
||||
</Text>
|
||||
</Box>
|
||||
)}
|
||||
{queued && (
|
||||
<Box style={{ padding: `0 ${config.space.S400}` }}>
|
||||
<Text size="T200" priority="300">
|
||||
Queued. Will send when you're back online
|
||||
</Text>
|
||||
</Box>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
};
|
||||
|
||||
@@ -25,6 +25,12 @@ export type ClientConfig = {
|
||||
* Unset: the bundled copy on this origin. Ignored in the desktop app.
|
||||
*/
|
||||
elementCallUrl?: string;
|
||||
|
||||
/**
|
||||
* Absolute https URL of the public web app (e.g. https://chat.lotusguild.org).
|
||||
* The desktop app sets it so it can hand calls it can't make to the browser.
|
||||
*/
|
||||
webAppUrl?: string;
|
||||
};
|
||||
|
||||
const ClientConfigContext = createContext<ClientConfig | null>(null);
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { lotusLinkBases, lotusShareBase } from './useLotusLinkBase';
|
||||
|
||||
const LOCAL = 'http://localhost:44548/#/';
|
||||
const WEB = 'https://chat.lotusguild.org';
|
||||
|
||||
test('web: shared links use the page origin', () => {
|
||||
assert.equal(lotusShareBase(WEB, false, WEB), WEB);
|
||||
assert.deepEqual(lotusLinkBases(WEB, false, undefined), [WEB]);
|
||||
});
|
||||
|
||||
test('desktop with webAppUrl: shared links use the public web app', () => {
|
||||
assert.equal(lotusShareBase(LOCAL, true, `${WEB}/`), WEB);
|
||||
assert.deepEqual(lotusLinkBases(LOCAL, true, WEB), [LOCAL, WEB]);
|
||||
});
|
||||
|
||||
test('desktop without a valid webAppUrl falls back to the origin', () => {
|
||||
[undefined, '', 'http://chat.lotusguild.org', 'nonsense'].forEach((v) => {
|
||||
assert.equal(lotusShareBase(LOCAL, true, v), LOCAL, String(v));
|
||||
assert.deepEqual(lotusLinkBases(LOCAL, true, v), [LOCAL]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,37 @@
|
||||
import { useMemo } from 'react';
|
||||
import { useClientConfig } from './useClientConfig';
|
||||
import { isTauri } from './useTauri';
|
||||
import { getOriginBaseUrl } from '../pages/pathUtils';
|
||||
import { resolveWebAppUrl } from '../utils/callInBrowser';
|
||||
|
||||
/**
|
||||
* [Gitea #248] Base URL for Lotus links meant for other people.
|
||||
*
|
||||
* On the web that's this page's origin. In the desktop app the page is served
|
||||
* from a local address (and hash-routed), which nobody else can open, so use
|
||||
* the public web app from config `webAppUrl` (web path routing) instead.
|
||||
* Without a valid `webAppUrl` it falls back to the origin, as before.
|
||||
*/
|
||||
export const lotusShareBase = (originBase: string, desktop: boolean, webAppUrl: unknown): string =>
|
||||
(desktop && resolveWebAppUrl(webAppUrl)) || originBase;
|
||||
|
||||
/**
|
||||
* Every base a Lotus link to this deployment may start with: the origin, plus
|
||||
* the public web app in the desktop app, so a shared https link opens in-app.
|
||||
*/
|
||||
export const lotusLinkBases = (
|
||||
originBase: string,
|
||||
desktop: boolean,
|
||||
webAppUrl: unknown,
|
||||
): string[] => {
|
||||
const shared = lotusShareBase(originBase, desktop, webAppUrl);
|
||||
return shared === originBase ? [originBase] : [originBase, shared];
|
||||
};
|
||||
|
||||
export const useLotusShareBase = (): string => {
|
||||
const { hashRouter, webAppUrl } = useClientConfig();
|
||||
return useMemo(
|
||||
() => lotusShareBase(getOriginBaseUrl(hashRouter), isTauri(), webAppUrl),
|
||||
[hashRouter, webAppUrl],
|
||||
);
|
||||
};
|
||||
@@ -31,6 +31,7 @@ import { allInvitesAtom } from '../../state/room-list/inviteList';
|
||||
import { useMatrixClient } from '../../hooks/useMatrixClient';
|
||||
import { useClientConfig } from '../../hooks/useClientConfig';
|
||||
import { useHydrateMsgDrafts } from '../../hooks/useHydrateMsgDrafts';
|
||||
import { OutboxFeature } from '../../features/outbox/OutboxFeature';
|
||||
import { useSearchCacheInvalidation } from '../../utils/searchCacheInvalidation';
|
||||
import { ClockSkewMonitor } from '../../utils/clockSkew';
|
||||
import { clockSkewAtom } from '../../state/clockSkew';
|
||||
@@ -77,6 +78,7 @@ import { KeyboardShortcutsDialog, useKeyboardShortcutsTrigger } from '../../feat
|
||||
import { useRoomsListener } from '../../hooks/useRoomsListener';
|
||||
import { threadNotificationsAtom } from '../../state/threadNotifications';
|
||||
import { roomIdToActiveThreadIdAtomFamily } from '../../state/room/thread';
|
||||
import { lotusLinkBases } from '../../hooks/useLotusLinkBase';
|
||||
import {
|
||||
getThreadNotificationMode,
|
||||
shouldNotifyThreadReply,
|
||||
@@ -118,11 +120,12 @@ function SystemEmojiFeature() {
|
||||
|
||||
// [Gitea #103] Mirror the privacy toggle into the html parser's module flag.
|
||||
function LotusPermalinkFeature() {
|
||||
const { hashRouter } = useClientConfig();
|
||||
const { hashRouter, webAppUrl } = useClientConfig();
|
||||
useEffect(() => {
|
||||
setLotusPermalinkBase(getOriginBaseUrl(hashRouter));
|
||||
// [Gitea #248] In the desktop app, links to the public web app count too.
|
||||
setLotusPermalinkBase(lotusLinkBases(getOriginBaseUrl(hashRouter), isTauriApp(), webAppUrl));
|
||||
return () => setLotusPermalinkBase(undefined);
|
||||
}, [hashRouter]);
|
||||
}, [hashRouter, webAppUrl]);
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -1105,6 +1108,7 @@ export function ClientNonUIFeatures({ children }: ClientNonUIFeaturesProps) {
|
||||
<TauriDesktopFeatures />
|
||||
<CloseBehaviorPrompt />
|
||||
<ConsentRequiredPrompt />
|
||||
<OutboxFeature />
|
||||
<LotusDenoiseFeature />
|
||||
<DeepLinkNavigator />
|
||||
<KeyboardShortcutsFeature />
|
||||
|
||||
@@ -49,13 +49,7 @@ import { roomToParentsAtom } from '../../../state/room/roomToParents';
|
||||
import { allRoomsAtom } from '../../../state/room-list/roomList';
|
||||
import { useAnyRoomLiveCall } from '../../../hooks/useSpaceLiveCall';
|
||||
import { LiveDot } from './SpaceTabs.css';
|
||||
import {
|
||||
getOriginBaseUrl,
|
||||
getSpaceLobbyPath,
|
||||
getSpacePath,
|
||||
joinPathComponent,
|
||||
} from '../../pathUtils';
|
||||
import { useClientConfig } from '../../../hooks/useClientConfig';
|
||||
import { getSpaceLobbyPath, getSpacePath, joinPathComponent } from '../../pathUtils';
|
||||
import {
|
||||
SidebarAvatar,
|
||||
SidebarItem,
|
||||
@@ -102,6 +96,7 @@ import { settingsAtom } from '../../../state/settings';
|
||||
import { useOpenSpaceSettings } from '../../../state/hooks/spaceSettings';
|
||||
import { useRoomCreators } from '../../../hooks/useRoomCreators';
|
||||
import { useRoomPermissions } from '../../../hooks/useRoomPermissions';
|
||||
import { useLotusShareBase } from '../../../hooks/useLotusLinkBase';
|
||||
import { InviteUserPrompt } from '../../../components/invite-user-prompt';
|
||||
|
||||
type SpaceMenuProps = {
|
||||
@@ -112,7 +107,7 @@ type SpaceMenuProps = {
|
||||
const SpaceMenu = forwardRef<HTMLDivElement, SpaceMenuProps>(
|
||||
({ room, requestClose, onUnpin }, ref) => {
|
||||
const mx = useMatrixClient();
|
||||
const { hashRouter } = useClientConfig();
|
||||
const lotusBase = useLotusShareBase();
|
||||
const [hideActivity] = useSetting(settingsAtom, 'hideActivity');
|
||||
const roomToParents = useAtomValue(roomToParentsAtom);
|
||||
const powerLevels = usePowerLevels(room);
|
||||
@@ -152,9 +147,7 @@ const SpaceMenu = forwardRef<HTMLDivElement, SpaceMenuProps>(
|
||||
const handleCopyLotusLink = () => {
|
||||
const roomIdOrAlias = getCanonicalAliasOrRoomId(mx, room.roomId);
|
||||
const viaServers = isRoomAlias(roomIdOrAlias) ? undefined : getViaServers(room);
|
||||
copyToClipboard(
|
||||
getLotusSpacePermalink(getOriginBaseUrl(hashRouter), roomIdOrAlias, viaServers),
|
||||
);
|
||||
copyToClipboard(getLotusSpacePermalink(lotusBase, roomIdOrAlias, viaServers));
|
||||
requestClose();
|
||||
};
|
||||
|
||||
|
||||
@@ -39,13 +39,7 @@ import {
|
||||
NavItemContent,
|
||||
NavLink,
|
||||
} from '../../../components/nav';
|
||||
import {
|
||||
getOriginBaseUrl,
|
||||
getSpaceLobbyPath,
|
||||
getSpaceRoomPath,
|
||||
getSpaceSearchPath,
|
||||
} from '../../pathUtils';
|
||||
import { useClientConfig } from '../../../hooks/useClientConfig';
|
||||
import { getSpaceLobbyPath, getSpaceRoomPath, getSpaceSearchPath } from '../../pathUtils';
|
||||
import { getCanonicalAliasOrRoomId, isRoomAlias } from '../../../utils/matrix';
|
||||
import { useSelectedRoom } from '../../../hooks/router/useSelectedRoom';
|
||||
import {
|
||||
@@ -92,6 +86,7 @@ import { ContainerColor } from '../../../styles/ContainerColor.css';
|
||||
import { AsyncStatus, useAsyncCallback } from '../../../hooks/useAsyncCallback';
|
||||
import { BreakWord } from '../../../styles/Text.css';
|
||||
import { InviteUserPrompt } from '../../../components/invite-user-prompt';
|
||||
import { useLotusShareBase } from '../../../hooks/useLotusLinkBase';
|
||||
import { useCallEmbed } from '../../../hooks/useCallEmbed';
|
||||
|
||||
type SpaceMenuProps = {
|
||||
@@ -100,7 +95,7 @@ type SpaceMenuProps = {
|
||||
};
|
||||
const SpaceMenu = forwardRef<HTMLDivElement, SpaceMenuProps>(({ room, requestClose }, ref) => {
|
||||
const mx = useMatrixClient();
|
||||
const { hashRouter } = useClientConfig();
|
||||
const lotusBase = useLotusShareBase();
|
||||
const [hideActivity] = useSetting(settingsAtom, 'hideActivity');
|
||||
const [developerTools] = useSetting(settingsAtom, 'developerTools');
|
||||
const roomToParents = useAtomValue(roomToParentsAtom);
|
||||
@@ -137,9 +132,7 @@ const SpaceMenu = forwardRef<HTMLDivElement, SpaceMenuProps>(({ room, requestClo
|
||||
const handleCopyLotusLink = () => {
|
||||
const roomIdOrAlias = getCanonicalAliasOrRoomId(mx, room.roomId);
|
||||
const viaServers = isRoomAlias(roomIdOrAlias) ? undefined : getViaServers(room);
|
||||
copyToClipboard(
|
||||
getLotusSpacePermalink(getOriginBaseUrl(hashRouter), roomIdOrAlias, viaServers),
|
||||
);
|
||||
copyToClipboard(getLotusSpacePermalink(lotusBase, roomIdOrAlias, viaServers));
|
||||
requestClose();
|
||||
};
|
||||
|
||||
|
||||
@@ -122,11 +122,15 @@ const cleanHref = (href: string): string =>
|
||||
stripTrackingOnRender ? stripTrackingParams(href) : href;
|
||||
|
||||
// [Gitea #130] Links to THIS deployment's room routes render and click like
|
||||
// matrix.to links. The base is set once from the client config
|
||||
// (ClientNonUIFeatures) because this module has no access to hooks.
|
||||
let lotusPermalinkBase: string | undefined;
|
||||
export const setLotusPermalinkBase = (baseUrl: string | undefined): void => {
|
||||
lotusPermalinkBase = baseUrl;
|
||||
// matrix.to links. The bases are set once from the client config
|
||||
// (ClientNonUIFeatures) because this module has no access to hooks. [Gitea
|
||||
// #248] Several: the desktop app knows both its local origin and the public web
|
||||
// app (`webAppUrl`), and people share the public one.
|
||||
let lotusPermalinkBases: string[] = [];
|
||||
export const setLotusPermalinkBase = (baseUrls: string | string[] | undefined): void => {
|
||||
lotusPermalinkBases = (Array.isArray(baseUrls) ? baseUrls : [baseUrls]).filter(
|
||||
(b): b is string => !!b,
|
||||
);
|
||||
};
|
||||
/**
|
||||
* The matrix.to form of `href` when it is a matrix.to link or a Lotus
|
||||
@@ -134,7 +138,11 @@ export const setLotusPermalinkBase = (baseUrl: string | undefined): void => {
|
||||
*/
|
||||
export const toMatrixToHref = (href: string): string | undefined => {
|
||||
if (testMatrixTo(href)) return href;
|
||||
return lotusPermalinkBase ? lotusPermalinkToMatrixTo(lotusPermalinkBase, href) : undefined;
|
||||
for (const base of lotusPermalinkBases) {
|
||||
const matrixTo = lotusPermalinkToMatrixTo(base, href);
|
||||
if (matrixTo) return matrixTo;
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
export const LINKIFY_OPTS: LinkifyOpts = {
|
||||
|
||||
@@ -36,6 +36,7 @@ test('clearPlaintextCaches removes every plaintext/PII localStorage key', () =>
|
||||
store.set('cinny_recent_forward_targets_v1', '[]');
|
||||
store.set('cinny_recent_gifs_v1', '[]');
|
||||
store.set('cinny_recent_stickers_v1', '[]');
|
||||
store.set('lotus_outbox_v1', '{"userId":"@me:server","entries":[]}');
|
||||
removed.length = 0;
|
||||
|
||||
clearPlaintextCaches();
|
||||
@@ -47,6 +48,7 @@ test('clearPlaintextCaches removes every plaintext/PII localStorage key', () =>
|
||||
'cinny_recent_forward_targets_v1',
|
||||
'cinny_recent_gifs_v1',
|
||||
'cinny_recent_stickers_v1',
|
||||
'lotus_outbox_v1', // [Gitea #112] unsent message content
|
||||
]) {
|
||||
assert.ok(removed.includes(key), `${key} cleared`);
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@ import { clearRecentStickers } from './recentStickers';
|
||||
import { clearNavToActivePathStore } from './navToActivePath';
|
||||
import { DRAFT_MSG_KEY_PREFIX } from '../utils/draft';
|
||||
import { clearCallSession } from '../utils/callRejoin';
|
||||
import { clearOutbox } from '../utils/outbox';
|
||||
|
||||
/**
|
||||
* [Gitea #41] Wipe every persisted composer draft (`draft-msg-<roomId>`). Drafts
|
||||
@@ -44,6 +45,7 @@ const clearMsgDrafts = (): void => {
|
||||
* - `cinny_recent_forward_targets_v1` — recent forward contact/room graph (PII)
|
||||
* - `cinny_recent_gifs_v1` / `cinny_recent_stickers_v1` — media the user sent
|
||||
* - `navToActivePath<userId>` — per-space last-visited room paths (needs userId)
|
||||
* - `lotus_outbox_v1` — decrypted content of messages not yet sent ([Gitea #112])
|
||||
* - `draft-msg-*` — unsent composer drafts (decrypted message text, unscoped by
|
||||
* user — see [Gitea #41]; previously deliberately preserved across logout
|
||||
* (N98), which let the next account on this device see/send a prior user's
|
||||
@@ -93,6 +95,7 @@ export const clearPlaintextCaches = (userId?: string): void => {
|
||||
clearRecentGifs();
|
||||
clearRecentStickers();
|
||||
clearMsgDrafts();
|
||||
clearOutbox();
|
||||
clearCallSession();
|
||||
clearStatusMessage();
|
||||
if (userId) clearNavToActivePathStore(userId);
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
import { atom } from 'jotai';
|
||||
|
||||
/**
|
||||
* [Gitea #112] True while the client can't reach the homeserver (sync is
|
||||
* reconnecting / erroring, or the browser reports offline). Messages that
|
||||
* failed for network reasons show "Queued" instead of "Failed to send" while
|
||||
* this is set; the outbox sends them again once it clears.
|
||||
*/
|
||||
export const sendOfflineAtom = atom(false);
|
||||
@@ -0,0 +1,32 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { getCallInBrowserUrl, resolveWebAppUrl } from './callInBrowser';
|
||||
|
||||
test('resolveWebAppUrl keeps an https origin (+ path) without a trailing slash', () => {
|
||||
assert.equal(resolveWebAppUrl('https://chat.example.org'), 'https://chat.example.org');
|
||||
assert.equal(resolveWebAppUrl('https://chat.example.org/'), 'https://chat.example.org');
|
||||
assert.equal(resolveWebAppUrl('https://example.org/chat/'), 'https://example.org/chat');
|
||||
assert.equal(resolveWebAppUrl('https://chat.example.org/?x=1#y'), 'https://chat.example.org');
|
||||
});
|
||||
|
||||
test('resolveWebAppUrl rejects anything but absolute https', () => {
|
||||
[
|
||||
undefined,
|
||||
null,
|
||||
1,
|
||||
'',
|
||||
' ',
|
||||
'/home',
|
||||
'http://chat.example.org',
|
||||
'not a url',
|
||||
['javascript', 'alert(1)'].join(':'),
|
||||
'data:text/html,x',
|
||||
].forEach((v) => assert.equal(resolveWebAppUrl(v), undefined, String(v)));
|
||||
});
|
||||
|
||||
test('getCallInBrowserUrl points at the room in the web app (no auto-join)', () => {
|
||||
const url = getCallInBrowserUrl('https://chat.example.org', '!room:example.org');
|
||||
assert.equal(url, 'https://chat.example.org/home/!room%3Aexample.org');
|
||||
assert.ok(!/join|call=/i.test(url ?? ''));
|
||||
assert.equal(getCallInBrowserUrl(undefined, '!room:example.org'), undefined);
|
||||
});
|
||||
@@ -0,0 +1,27 @@
|
||||
import { getLotusRoomPermalink } from '../plugins/lotus-permalink';
|
||||
|
||||
/**
|
||||
* The public web app's address from config.json `webAppUrl` (the desktop app
|
||||
* sets it; its own origin is a local server). Absolute https only; anything
|
||||
* else is ignored.
|
||||
*/
|
||||
export const resolveWebAppUrl = (value: unknown): string | undefined => {
|
||||
if (typeof value !== 'string' || value.trim() === '') return undefined;
|
||||
try {
|
||||
const url = new URL(value);
|
||||
if (url.protocol !== 'https:') return undefined;
|
||||
return url.origin + url.pathname.replace(/\/+$/, '');
|
||||
} catch {
|
||||
return undefined;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Where to send the user to take a call this app can't make: the room in the
|
||||
* web app (they press Join there themselves — never an auto-join link, which
|
||||
* a crafted URL could abuse to open someone's mic).
|
||||
*/
|
||||
export const getCallInBrowserUrl = (
|
||||
webAppUrl: string | undefined,
|
||||
roomId: string,
|
||||
): string | undefined => (webAppUrl ? getLotusRoomPermalink(webAppUrl, roomId) : undefined);
|
||||
@@ -0,0 +1,131 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import {
|
||||
OUTBOX_AUTOSEND_MS,
|
||||
OUTBOX_MAX_ENTRIES,
|
||||
OutboxEntry,
|
||||
isRetryableSendError,
|
||||
outboxRetryDelayMs,
|
||||
parseOutbox,
|
||||
planRestore,
|
||||
shouldKeepInOutbox,
|
||||
withEntry,
|
||||
withoutEntry,
|
||||
} from './outbox';
|
||||
|
||||
const entry = (txnId: string, ts: number, roomId = '!a:hs'): OutboxEntry => ({
|
||||
txnId,
|
||||
roomId,
|
||||
threadId: null,
|
||||
type: 'm.room.message',
|
||||
content: { msgtype: 'm.text', body: txnId },
|
||||
ts,
|
||||
});
|
||||
|
||||
test('keeps message-like events, not call signalling or redactions', () => {
|
||||
assert.equal(shouldKeepInOutbox('m.room.message', { body: 'hi' }), true);
|
||||
assert.equal(shouldKeepInOutbox('m.reaction', { 'm.relates_to': { event_id: '$x' } }), true);
|
||||
assert.equal(shouldKeepInOutbox('org.matrix.msc3381.poll.start', {}), true);
|
||||
assert.equal(shouldKeepInOutbox('org.matrix.msc4075.rtc.notification', {}), false);
|
||||
assert.equal(shouldKeepInOutbox('m.call.invite', {}), false);
|
||||
assert.equal(shouldKeepInOutbox('m.room.redaction', {}), false);
|
||||
});
|
||||
|
||||
test('skips events that point at another unsent message (local id)', () => {
|
||||
assert.equal(
|
||||
shouldKeepInOutbox('m.reaction', { 'm.relates_to': { event_id: '~!a:hs:m123' } }),
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
shouldKeepInOutbox('m.room.message', {
|
||||
body: 'reply',
|
||||
'm.relates_to': { 'm.in_reply_to': { event_id: '~!a:hs:m1' } },
|
||||
}),
|
||||
false,
|
||||
);
|
||||
assert.equal(
|
||||
shouldKeepInOutbox('m.room.message', {
|
||||
body: 'reply',
|
||||
'm.relates_to': { 'm.in_reply_to': { event_id: '$real' } },
|
||||
}),
|
||||
true,
|
||||
);
|
||||
});
|
||||
|
||||
test('retryable: connection loss, timeouts, rate limits, server errors', () => {
|
||||
const connectionError = new Error('fetch failed');
|
||||
Object.defineProperty(connectionError, 'name', { value: 'ConnectionError' });
|
||||
assert.equal(isRetryableSendError(connectionError), true);
|
||||
assert.equal(isRetryableSendError({ httpStatus: 429 }), true);
|
||||
assert.equal(isRetryableSendError({ httpStatus: 408 }), true);
|
||||
assert.equal(isRetryableSendError({ httpStatus: 502 }), true);
|
||||
});
|
||||
|
||||
test('not retryable: client errors, consent, unknown or missing errors', () => {
|
||||
assert.equal(isRetryableSendError({ httpStatus: 403, errcode: 'M_FORBIDDEN' }), false);
|
||||
assert.equal(isRetryableSendError({ httpStatus: 403, errcode: 'M_CONSENT_NOT_GIVEN' }), false);
|
||||
assert.equal(isRetryableSendError({ httpStatus: 400 }), false);
|
||||
assert.equal(isRetryableSendError(new Error('encryption failed')), false);
|
||||
assert.equal(isRetryableSendError(undefined), false);
|
||||
assert.equal(isRetryableSendError(null), false);
|
||||
});
|
||||
|
||||
test('parse: only this user, only well-formed entries, junk tolerated', () => {
|
||||
const good = entry('m1', 1);
|
||||
const raw = JSON.stringify({ userId: '@me:hs', entries: [good, { txnId: 5 }, null] });
|
||||
assert.deepEqual(parseOutbox(raw, '@me:hs'), [good]);
|
||||
assert.deepEqual(parseOutbox(raw, '@other:hs'), []);
|
||||
assert.deepEqual(parseOutbox('{not json', '@me:hs'), []);
|
||||
assert.deepEqual(parseOutbox(null, '@me:hs'), []);
|
||||
});
|
||||
|
||||
test('withEntry: first write wins, sorted, capped (oldest dropped)', () => {
|
||||
const a = entry('a', 2);
|
||||
let list = withEntry([], a);
|
||||
assert.equal(withEntry(list, { ...a, content: { body: 'changed' } }), list);
|
||||
list = withEntry(list, entry('b', 1));
|
||||
assert.deepEqual(
|
||||
list.map((e) => e.txnId),
|
||||
['b', 'a'],
|
||||
);
|
||||
let many: OutboxEntry[] = [];
|
||||
for (let i = 0; i < OUTBOX_MAX_ENTRIES + 5; i += 1) many = withEntry(many, entry(`t${i}`, i));
|
||||
assert.equal(many.length, OUTBOX_MAX_ENTRIES);
|
||||
assert.equal(many[0].txnId, 't5');
|
||||
});
|
||||
|
||||
test('withoutEntry: removes, and returns the same list when absent', () => {
|
||||
const list = [entry('a', 1), entry('b', 2)];
|
||||
assert.deepEqual(
|
||||
withoutEntry(list, 'a').map((e) => e.txnId),
|
||||
['b'],
|
||||
);
|
||||
assert.equal(withoutEntry(list, 'zzz'), list);
|
||||
});
|
||||
|
||||
test('restore plan: drops delivered / left rooms, auto-sends only recent ones', () => {
|
||||
const now = 10 * OUTBOX_AUTOSEND_MS;
|
||||
const recent = entry('recent', now - 60_000);
|
||||
const old = entry('old', now - OUTBOX_AUTOSEND_MS - 1);
|
||||
const delivered = entry('delivered', now - 1000);
|
||||
const left = entry('left', now - 1000, '!left:hs');
|
||||
const plan = planRestore(
|
||||
[recent, left, old, delivered],
|
||||
now,
|
||||
(roomId) => roomId !== '!left:hs',
|
||||
(e) => e.txnId === 'delivered',
|
||||
);
|
||||
assert.deepEqual(
|
||||
plan.restore.map((e) => e.txnId),
|
||||
['old', 'recent'],
|
||||
);
|
||||
assert.deepEqual([...plan.autoSend], ['recent']);
|
||||
assert.deepEqual(plan.drop.map((e) => e.txnId).sort(), ['delivered', 'left']);
|
||||
});
|
||||
|
||||
test('blip retry delay backs off and is capped at a minute', () => {
|
||||
assert.deepEqual(
|
||||
[0, 1, 2, 3, 4, 9].map(outboxRetryDelayMs),
|
||||
[5000, 10000, 20000, 40000, 60000, 60000],
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,182 @@
|
||||
import { IContent } from 'matrix-js-sdk';
|
||||
|
||||
/**
|
||||
* [Gitea #112] Offline outbox: unsent messages survive a reload and are
|
||||
* retried when the connection comes back.
|
||||
*
|
||||
* The SDK keeps local echoes in memory only (chronological pending ordering),
|
||||
* so a reload used to drop every message that hadn't reached the server. Each
|
||||
* own message send is mirrored here (type + clear content + txnId) from its
|
||||
* first local echo until the server confirms it or the user cancels it. On
|
||||
* the next start it is put back as a failed local echo (Retry / Cancel as
|
||||
* usual) and, if it's recent, sent again with the SAME txnId — the server
|
||||
* deduplicates a transaction it already accepted.
|
||||
*
|
||||
* The content is the decrypted message, like a composer draft: it lives in
|
||||
* localStorage until sent and is wiped on logout (clearPlaintextCaches).
|
||||
*/
|
||||
|
||||
export type OutboxEntry = {
|
||||
txnId: string;
|
||||
roomId: string;
|
||||
threadId: string | null;
|
||||
type: string;
|
||||
content: IContent;
|
||||
/** When the message was first sent (local echo timestamp, ms). */
|
||||
ts: number;
|
||||
};
|
||||
|
||||
type Stored = { userId: string; entries: OutboxEntry[] };
|
||||
|
||||
const STORAGE_KEY = 'lotus_outbox_v1';
|
||||
/** Hard cap so a long offline stretch can't grow localStorage without bound. */
|
||||
export const OUTBOX_MAX_ENTRIES = 100;
|
||||
/**
|
||||
* Restored messages younger than this are sent again automatically after a
|
||||
* reload; older ones come back as "Failed to send" and wait for the user
|
||||
* (sending a message typed hours ago without asking would surprise people).
|
||||
*/
|
||||
export const OUTBOX_AUTOSEND_MS = 60 * 60 * 1000;
|
||||
/** Auto-retries per message per session (one per reconnect). */
|
||||
export const OUTBOX_MAX_AUTO_RETRIES = 10;
|
||||
|
||||
/** Delay before automatic retry number `attempt` (0-based) after a blip. */
|
||||
export const outboxRetryDelayMs = (attempt: number): number =>
|
||||
Math.min(5000 * 2 ** Math.max(0, attempt), 60_000);
|
||||
|
||||
/** Message-like events worth keeping. Not call signalling, not redactions. */
|
||||
export const OUTBOX_EVENT_TYPES: ReadonlySet<string> = new Set([
|
||||
'm.room.message',
|
||||
'm.sticker',
|
||||
'm.reaction',
|
||||
'm.poll.start',
|
||||
'm.poll.response',
|
||||
'm.poll.end',
|
||||
'org.matrix.msc3381.poll.start',
|
||||
'org.matrix.msc3381.poll.response',
|
||||
'org.matrix.msc3381.poll.end',
|
||||
]);
|
||||
|
||||
const relatesToPendingEvent = (content: IContent): boolean => {
|
||||
const rel = content['m.relates_to'] as
|
||||
| { event_id?: unknown; 'm.in_reply_to'?: { event_id?: unknown } }
|
||||
| undefined;
|
||||
const ids = [rel?.event_id, rel?.['m.in_reply_to']?.event_id];
|
||||
// A local echo's id ("~!room:txn") means nothing after a reload.
|
||||
return ids.some((id) => typeof id === 'string' && id.startsWith('~'));
|
||||
};
|
||||
|
||||
/** Whether a send should be mirrored into the outbox. */
|
||||
export const shouldKeepInOutbox = (type: string, content: IContent): boolean =>
|
||||
OUTBOX_EVENT_TYPES.has(type) && !relatesToPendingEvent(content);
|
||||
|
||||
/**
|
||||
* A failure the network is to blame for: no connection (the SDK's
|
||||
* ConnectionError), a timeout, rate limiting or a server error. Anything else
|
||||
* (403, consent, bad request, encryption failure) needs the user.
|
||||
*/
|
||||
export const isRetryableSendError = (err: unknown): boolean => {
|
||||
if (!err || typeof err !== 'object') return false;
|
||||
const { name, httpStatus } = err as { name?: unknown; httpStatus?: unknown };
|
||||
if (name === 'ConnectionError') return true;
|
||||
if (typeof httpStatus !== 'number') return false;
|
||||
return httpStatus === 408 || httpStatus === 429 || httpStatus >= 500;
|
||||
};
|
||||
|
||||
const isEntry = (e: unknown): e is OutboxEntry => {
|
||||
if (!e || typeof e !== 'object') return false;
|
||||
const o = e as Record<string, unknown>;
|
||||
return (
|
||||
typeof o.txnId === 'string' &&
|
||||
typeof o.roomId === 'string' &&
|
||||
(o.threadId === null || typeof o.threadId === 'string') &&
|
||||
typeof o.type === 'string' &&
|
||||
!!o.content &&
|
||||
typeof o.content === 'object' &&
|
||||
typeof o.ts === 'number'
|
||||
);
|
||||
};
|
||||
|
||||
/** Parse the stored outbox, keeping only this user's well-formed entries. */
|
||||
export const parseOutbox = (raw: string | null, userId: string): OutboxEntry[] => {
|
||||
if (!raw) return [];
|
||||
try {
|
||||
const parsed = JSON.parse(raw) as Partial<Stored>;
|
||||
if (parsed.userId !== userId || !Array.isArray(parsed.entries)) return [];
|
||||
return parsed.entries.filter(isEntry);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
};
|
||||
|
||||
/** Add (or keep) an entry: first write wins, oldest dropped past the cap. */
|
||||
export const withEntry = (entries: OutboxEntry[], entry: OutboxEntry): OutboxEntry[] => {
|
||||
if (entries.some((e) => e.txnId === entry.txnId)) return entries;
|
||||
const next = [...entries, entry].sort((a, b) => a.ts - b.ts);
|
||||
return next.length > OUTBOX_MAX_ENTRIES ? next.slice(next.length - OUTBOX_MAX_ENTRIES) : next;
|
||||
};
|
||||
|
||||
export const withoutEntry = (entries: OutboxEntry[], txnId: string): OutboxEntry[] =>
|
||||
entries.some((e) => e.txnId === txnId) ? entries.filter((e) => e.txnId !== txnId) : entries;
|
||||
|
||||
export type RestorePlan = {
|
||||
/** Put back as failed local echoes, oldest first. */
|
||||
restore: OutboxEntry[];
|
||||
/** Subset of `restore` to send again right away. */
|
||||
autoSend: Set<string>;
|
||||
/** Already delivered or no longer sendable: forget them. */
|
||||
drop: OutboxEntry[];
|
||||
};
|
||||
|
||||
/**
|
||||
* Decide what to do with the stored outbox on start.
|
||||
* `canSend(roomId)`: the user is still joined; `delivered(entry)`: the
|
||||
* server already has it (the transaction id came back down /sync).
|
||||
*/
|
||||
export const planRestore = (
|
||||
entries: OutboxEntry[],
|
||||
now: number,
|
||||
canSend: (roomId: string) => boolean,
|
||||
delivered: (entry: OutboxEntry) => boolean,
|
||||
): RestorePlan => {
|
||||
const restore: OutboxEntry[] = [];
|
||||
const autoSend = new Set<string>();
|
||||
const drop: OutboxEntry[] = [];
|
||||
[...entries]
|
||||
.sort((a, b) => a.ts - b.ts)
|
||||
.forEach((entry) => {
|
||||
if (!canSend(entry.roomId) || delivered(entry)) {
|
||||
drop.push(entry);
|
||||
return;
|
||||
}
|
||||
restore.push(entry);
|
||||
if (now - entry.ts < OUTBOX_AUTOSEND_MS) autoSend.add(entry.txnId);
|
||||
});
|
||||
return { restore, autoSend, drop };
|
||||
};
|
||||
|
||||
export const loadOutbox = (userId: string): OutboxEntry[] => {
|
||||
try {
|
||||
return parseOutbox(localStorage.getItem(STORAGE_KEY), userId);
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
};
|
||||
|
||||
export const saveOutbox = (userId: string, entries: OutboxEntry[]): void => {
|
||||
try {
|
||||
if (entries.length === 0) localStorage.removeItem(STORAGE_KEY);
|
||||
else localStorage.setItem(STORAGE_KEY, JSON.stringify({ userId, entries } satisfies Stored));
|
||||
} catch {
|
||||
// Storage full or blocked: the outbox is best-effort.
|
||||
}
|
||||
};
|
||||
|
||||
/** Wipe the outbox (logout): it holds decrypted message content. */
|
||||
export const clearOutbox = (): void => {
|
||||
try {
|
||||
localStorage.removeItem(STORAGE_KEY);
|
||||
} catch {
|
||||
/* localStorage unavailable — nothing to clear */
|
||||
}
|
||||
};
|
||||
@@ -898,6 +898,14 @@ globalStyle(
|
||||
boxShadow: '0 0 10px rgba(255,107,0,0.10)',
|
||||
},
|
||||
);
|
||||
// [Gitea #246] The poll's winning answer (after it ends).
|
||||
globalStyle(
|
||||
`body.${lotusTerminalBodyClass} [data-poll-content] [data-poll-answer][data-winner="true"]`,
|
||||
{
|
||||
border: '1px solid rgba(0,255,136,0.55) !important',
|
||||
boxShadow: '0 0 10px rgba(0,255,136,0.10)',
|
||||
},
|
||||
);
|
||||
globalStyle(`body.${lotusTerminalBodyClass} [data-poll-content] [data-poll-content-label]`, {
|
||||
color: 'rgba(0,212,255,0.60) !important',
|
||||
opacity: '1 !important',
|
||||
|
||||
Reference in New Issue
Block a user