Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
import { useEffect, useId, useLayoutEffect, useRef, useState, useSyncExternalStore, type CSSProperties, type ReactNode, type RefObject } from "react";
import { normalizeChatText, MAX_CHAT_CODE_POINTS, isThrow, type ReactionId } from "../../../shared/room-interactions";
import { RoomInteractionSession } from "../../lib/room-interactions";
import { labelParticipantNames } from "../../lib/viewer-presence";
import { useCopy } from "../../ui/copy";
import { Glyph } from "../../ui/icons";
import { BackButton, Btn } from "./primitives";
import { participantColor } from "./participant-color";
import { FloatingPanel } from "./FloatingPanel";
import { PawnSvg } from "./Pawn";
import { Couch, type CouchProps } from "./Couch";
import { RoomReaction } from "./RoomReaction";
import { RoomReactionPicker, type InteractionParticipant } from "./RoomReactionPicker";
import { RoomQuickReactions } from "./RoomQuickReactions";
import { RoomReactionActivity } from "./RoomReactionActivity";
import { RoomChatToggle } from "./RoomChatOverlay";
import { RoomChatSettings } from "./RoomChatSettings";
import { Tooltip } from "./Tooltip";
import { navigateTabs } from "../../ui/tab-navigation";
import "./room-interactions.css";
type Props = CouchProps & {
session: RoomInteractionSession | null;
/** The room voice owner supplies controls; moving the panel never moves capture ownership. */
voice?: {
content: (onSelect: (peerId: string, trigger: HTMLButtonElement) => void) => ReactNode;
settings: ReactNode;
controls: ReactNode;
};
};
export function RoomInteractions(props: Props) {
return props.session ? <ConnectedRoomInteractions key={props.session.key} {...props} session={props.session} /> : <Couch {...props} />;
}
type ConnectedProps = Props & { session: RoomInteractionSession };
function ConnectedRoomInteractions(props: ConnectedProps) {
const state = useSyncExternalStore(props.session.subscribe, props.session.getSnapshot);
// Disconnect retains admission; retirement clears it and disposes every chat surface.
return state.peerId ? <InteractionPanel {...props} state={state} /> : <Couch {...props} />;
}
function InteractionPanel({ session, state, voice, ...couch }: ConnectedProps & {
state: ReturnType<RoomInteractionSession["getSnapshot"]>;
}) {
const { t, vis } = useCopy();
const [chatOpen, setChatOpen] = useState(false);
const [chatDocument, setChatDocument] = useState<Document | null>(null);
const detached = Boolean(chatDocument && chatDocument !== document);
const [settingsOpen, setSettingsOpen] = useState<"chat" | "voice" | null>(null);
const [page, setPage] = useState<"chat" | "voice">("chat");
const [target, setTarget] = useState<string | null>(null);
const [panelTarget, setPanelTarget] = useState<{ peerId: string; trigger: HTMLElement } | null>(null);
const [draft, setDraft] = useState("");
const [lastSeen, setLastSeen] = useState<string | null>(null);
const [visible, setVisible] = useState(false);
const [following, setFollowing] = useState(true);
const area = useRef<HTMLDivElement>(null);
const anchor = useRef<HTMLButtonElement | null>(null);
const log = useRef<HTMLDivElement>(null);
const readingPosition = useRef(0);
const id = useId();
const menuId = `${id}-person`;
const participants: InteractionParticipant[] = [
...(couch.host ? [{ peerId: couch.host.key, displayName: couch.host.name }] : []),
...couch.entries.map(entry => ({ peerId: entry.key, displayName: entry.name })),
];
const latest = state.messages.at(-1)?.id ?? null;
const authors = labelParticipantNames(state.messages.map(message => message.sender));
const unseenIndex = state.messages.findIndex(message => message.id === lastSeen);
const unread = latest === lastSeen ? 0 : state.messages.length - unseenIndex - 1;
const canSend = state.ready && !state.pending && !state.coolingDown;
const person = participants.find(person => person.peerId === target);
const panelPerson = participants.find(person => person.peerId === panelTarget?.peerId);
const expressing = panelTarget?.trigger.id === `${id}-express`;
const latestReaction = state.reactions.at(-1);
const showVoice = Boolean(voice && page === "voice");
const showChat = !settingsOpen && !showVoice;
const rosterKey = participants.map(person => person.peerId).join(",");
const inspect = target === couch.host?.key && couch.host.onSelect ? () => { if (!couch.host?.selected) couch.host?.onSelect?.(); }
: couch.entries.some(entry => entry.key === target && entry.selectable !== false) && couch.onSelect
? () => { if (target !== couch.selectedKey) couch.onSelect?.(target!); } : undefined;
useEffect(() => {
const confirmed = state.confirmed;
if (confirmed?.payload.kind === "chat") {
const text = confirmed.payload.text;
setDraft(current => normalizeChatText(current) === text ? "" : current);
}
}, [state.confirmed]);
useEffect(() => {
if (panelTarget && !panelPerson) setPanelTarget(null);
}, [panelTarget, panelPerson]);
useLayoutEffect(() => {
const popup = document.getElementById(menuId);
if (!popup) return;
if (person && anchor.current?.isConnected) popup.showPopover({ source: anchor.current });
else popup.hidePopover();
}, [target, rosterKey, menuId]);
function openReactions(key: string, trigger: HTMLButtonElement) {
const popup = document.getElementById(menuId);
if (target === key && popup?.matches(":popover-open")) { popup.hidePopover(); return; }
anchor.current = trigger;
setTarget(key);
}
function sendReaction(reaction: ReactionId, targetPeerId?: string) {
session.send({ kind: "reaction", reaction, ...(targetPeerId ? { targetPeerId } : {}) });
}
function openPanelReactions(key: string, trigger: HTMLElement | null) {
if (trigger) setPanelTarget(current => current?.peerId === key && current.trigger === trigger ? null : { peerId: key, trigger });
}
useLayoutEffect(() => {
// Moving a popover between documents resets its native scroll offset.
// Content owns reading position; following the latest message remains below.
if (log.current) log.current.scrollTop = readingPosition.current;
}, [chatDocument]);
useEffect(() => {
if (!chatOpen || !log.current) return;
const owner = log.current.ownerDocument;
const view = owner.defaultView;
if (!view) return;
let active = true;
let inView = false;
const sync = () => { if (active) setVisible(inView && owner.visibilityState === "visible"); };
const observer = new view.IntersectionObserver(entries => {
const entry = entries.at(-1);
inView = Boolean(entry?.isIntersecting && entry.intersectionRatio > 0);
sync();
});
observer.observe(log.current);
owner.addEventListener("visibilitychange", sync);
return () => {
active = false;
observer.disconnect();
owner.removeEventListener("visibilitychange", sync);
setVisible(false);
};
}, [chatOpen, chatDocument, showChat]);
useEffect(() => {
if (!showChat || !chatOpen || !visible || !following || log.current?.ownerDocument.visibilityState !== "visible" ||
!log.current?.getClientRects().length) return;
setLastSeen(latest);
log.current.scrollTop = log.current.scrollHeight;
}, [latest, chatOpen, visible, following, chatDocument, showChat]);
return <div className="lr-room-interactions">
<div className="visually-hidden" role="log" aria-label={t("interaction.reactions")}
aria-live="polite" aria-relevant="additions">
{state.reactions.map(({ id, sender, payload }) => payload.kind === "reaction" && <p key={id}>
{t(payload.targetPeerId ? "interaction.receivedReaction" : "interaction.expressedReaction", {
sender: sender.displayName,
reaction: t(`interaction.reaction.${payload.reaction}`),
target: participants.find(person => person.peerId === payload.targetPeerId)?.displayName ?? t("interaction.participant"),
})}
</p>)}
</div>
<FloatingPanel id={id} trigger={`${id}-toggle`} icon={settingsOpen ? "sliders" : "chat"} className="lr-interaction-panel" detachable
title={t(settingsOpen === "voice" ? "voice.settings" : settingsOpen ? "interaction.settings" : "interaction.title")}
onOpenChange={(open, owner) => { setChatOpen(open); setChatDocument(owner); setPanelTarget(null); }}>
{!settingsOpen && <div className="lr-interaction-navigation">
{voice && <div className="lr-toggle lr-interaction-tabs" role="tablist" aria-label={t("interaction.title")}
style={{ "--lr-segments": 2, "--lr-selected-index": showVoice ? 1 : 0 } as CSSProperties} onKeyDown={navigateTabs}>
{(["chat", "voice"] as const).map(value => <button key={value} type="button" role="tab" id={`${id}-${value}-tab`}
aria-selected={page === value} aria-controls={`${id}-${value}-page`} tabIndex={page === value ? 0 : -1}
className={page === value ? "is-selected" : undefined} onClick={() => { setPanelTarget(null); setPage(value); }}>
<Glyph name={value === "chat" ? "chat" : "microphone"} size={16} />
<span className={vis ? "visually-hidden" : undefined}>{t(`interaction.${value}`)}</span>
</button>)}
</div>}
<Btn icon="sliders" quiet size="dense" title={showVoice ? "voice.settings" : "interaction.settings"}
hint={showVoice ? "hint-advanced" : "hint-chat-settings"}
onClick={() => { setPanelTarget(null); setSettingsOpen(showVoice ? "voice" : "chat"); }} />
</div>}
{settingsOpen && <div className="lr-interaction-back"><BackButton onClick={() => setSettingsOpen(null)} /></div>}
{settingsOpen && (settingsOpen === "voice" ? voice?.settings : <RoomChatSettings session={session} />)}
{panelTarget && panelPerson && <RoomQuickReactions key={panelTarget.peerId} id={`${id}-reactions`}
trigger={panelTarget.trigger} person={panelPerson} selfPeerId={state.peerId} hostPeerId={couch.host?.key}
reactionIds={state.reactionIds} canSend={canSend} onSend={sendReaction}
onClose={() => setPanelTarget(current => current === panelTarget ? null : current)} />}
<div className="lr-interaction-page" id={`${id}-chat-page`} role={voice ? "tabpanel" : undefined}
aria-labelledby={voice ? `${id}-chat-tab` : undefined} hidden={!showChat}>
<div className="lr-interaction-conversation">
<div className="lr-chat-history">
<div className="lr-chat-log" role="log" aria-label={t("interaction.chat")} aria-live="polite" aria-relevant="additions" tabIndex={0} ref={log}
onScroll={event => {
const node = event.currentTarget;
readingPosition.current = node.scrollTop;
setFollowing(node.scrollHeight - node.scrollTop - node.clientHeight < 40);
}}>
{state.messages.length === 0 ? <div className="lr-chat-empty">
<Glyph name="chat" size={24} /><p>{vis ? "···" : t("interaction.empty")}</p>
</div> : state.messages.map((message, index) => {
const previous = state.messages[index - 1];
const continuation = previous?.sender.peerId === message.sender.peerId && previous.sender.displayName === message.sender.displayName;
const participant = participants.find(person => person.peerId === message.sender.peerId);
const avatar = <PawnSvg color={participantColor(message.sender.peerId)} host={message.sender.role === "host"} />;
return <div key={message.id} className={`lr-chat-message${message.isSelf ? " is-self" : ""}${continuation ? " is-continuation" : ""}`}>
{!continuation && (participant ? <Tooltip className="lr-chat-avatar" kind="hint-reaction-picker"
text={vis ? undefined : t("interaction.withPerson", { name: participant.displayName })}>
<button type="button"
aria-label={t("interaction.withPerson", { name: participant.displayName })}
aria-expanded={panelTarget?.peerId === participant.peerId} aria-controls={`${id}-reactions`}
onClick={event => openPanelReactions(participant.peerId, event.currentTarget)}>{avatar}</button></Tooltip>
: <span className="lr-chat-avatar" aria-hidden="true">{avatar}</span>)}
<div className="lr-chat-bubble">
<span className={continuation ? "visually-hidden" : "lr-chat-author"}>{authors[index]!.label}
{message.sender.role === "host" && <span className="visually-hidden"> · {t("common.host")}</span>}</span>
<p>{message.payload.kind === "chat" && message.payload.text}</p>
</div>
</div>;
})}
</div>
{!following && state.messages.length > 0 && <button type="button" className="lr-chat-latest" onClick={() => {
setFollowing(true); log.current?.focus({ preventScroll: true });
}}><Glyph name="arrowDown" size={15} /><span className={vis ? "visually-hidden" : undefined}>
{unread ? t("interaction.unread", { count: String(unread) }) : t("interaction.latest")}</span></button>}
{chatOpen && showChat && latestReaction &&
<RoomReactionActivity key={latestReaction.id} reaction={latestReaction} participants={participants}
hostPeerId={couch.host?.key} now={session.now} />}
</div>
</div>
<form className="lr-chat-compose" onSubmit={event => {
event.preventDefault();
const text = normalizeChatText(draft);
if (text && canSend) { setFollowing(true); session.send({ kind: "chat", text }); }
}}>
<div className="lr-chat-input-row">
<input value={draft} onChange={event => setDraft(event.target.value)} maxLength={MAX_CHAT_CODE_POINTS * 2}
aria-label={t("interaction.placeholder")} placeholder={vis ? "···" : t("interaction.placeholder")}
name="message" autoComplete="off"
onKeyDown={event => { if (event.key === "Enter" && event.nativeEvent.isComposing) event.preventDefault(); }} />
<Btn type="submit" icon="send" title="interaction.send" hint="hint-chat-send" tone="primary" size="compact" busy={state.pending?.payload.kind === "chat"}
disabled={!canSend || !normalizeChatText(draft)} />
</div>
<div className="lr-chat-tools">
<Btn id={`${id}-express`} icon="smile" title="interaction.express" cap="interaction.express" size="dense" quiet
hint="hint-reaction-picker"
expanded={expressing} controls={`${id}-reactions`} tone={expressing ? "on" : undefined}
onClick={() => openPanelReactions(state.peerId!, (chatDocument ?? document).getElementById(`${id}-express`))} />
<RoomChatToggle session={session} size="dense" quiet />
<span className="lr-chat-count" aria-hidden="true" style={{ visibility: draft ? undefined : "hidden" }}>
{Array.from(draft).length} / {MAX_CHAT_CODE_POINTS}</span>
</div>
</form>
</div>
{voice && <>
<div className="lr-interaction-page" id={`${id}-voice-page`} role="tabpanel"
aria-labelledby={`${id}-voice-tab`} hidden={!showVoice || settingsOpen !== null}>
<div className="lr-interaction-conversation">
<div className="lr-floating-scroll lr-voice-history">{chatOpen && showVoice && !settingsOpen && voice.content(openPanelReactions)}</div>
{chatOpen && showVoice && latestReaction &&
<RoomReactionActivity key={latestReaction.id} reaction={latestReaction} participants={participants}
hostPeerId={couch.host?.key} now={session.now} />}
</div>
</div>
<div className="lr-interaction-voice-controls">{voice.controls}</div>
</>}
{(state.error || !state.ready) && <div className="lr-interaction-status" role="status">
<Glyph name={state.error ? "alert" : "network"} size={14} />
<span className={vis ? "visually-hidden" : undefined}>{t(state.error ? `interaction.error.${state.error}` : "interaction.reconnecting")}</span>
</div>}
</FloatingPanel>
<div className="lr-interaction-couch" ref={area}>
<Couch {...couch} participantAction={{ open: openReactions, target, controls: menuId }}
footerAction={<span className="lr-interaction-chat-toggle">
<Btn id={`${id}-toggle`} icon="chat" title={detached ? "interaction.focus" : chatOpen ? "interaction.close" : "interaction.open"}
cap="interaction.open" expanded={chatOpen} controls={detached ? undefined : id}
hint={detached ? "hint-window-detach" : chatOpen ? "hint-close" : "hint-chat-open"}
tone={chatOpen ? "on" : undefined} popoverTarget={detached ? undefined : id}
onClick={detached ? () => chatDocument?.defaultView?.focus() : undefined} />
{unread > 0 && <span className="lr-interaction-unread" aria-label={t("interaction.unread", { count: String(unread) })}>{unread}</span>}
</span>} />
<ReactionEffects state={state} participants={participants} area={area} now={session.now} />
</div>
<FloatingPanel id={menuId} trigger={anchor} compact anchorOnOpen icon="smile" className="lr-person-menu"
title={t("interaction.express")} onOpenChange={open => { if (!open) setTarget(null); }}>
<div className="lr-floating-scroll lr-person-menu-body">
<RoomReactionPicker person={person} selfPeerId={state.peerId} hostPeerId={couch.host?.key}
reactionIds={state.reactionIds} canSend={canSend} onSend={sendReaction} />
{state.error || !state.ready ? <div className="lr-interaction-status" role="status">
<Glyph name={state.error ? "alert" : "network"} size={14} />
<span className={vis ? "visually-hidden" : undefined}>{t(state.error ? `interaction.error.${state.error}` : "interaction.reconnecting")}</span>
</div> : null}
{inspect && <Tooltip className="lr-person-menu-details-hint" kind="hint-details" text={vis ? undefined : t("host.details")}>
<button type="button" className="lr-person-menu-details" onClick={() => { document.getElementById(menuId)?.hidePopover(); inspect(); }}>
<Glyph name="gauge" size={16} />{!vis && t("host.details")}
<span className="visually-hidden">{vis && t("host.details")}</span>
</button></Tooltip>}
</div>
</FloatingPanel>
</div>;
}
function ReactionEffects({ state, participants, area, now }: {
state: ReturnType<RoomInteractionSession["getSnapshot"]>;
participants: InteractionParticipant[];
area: RefObject<HTMLDivElement | null>;
now: () => number;
}) {
return state.reactions.map((reaction, index) => {
const payload = reaction.payload;
if (payload.kind !== "reaction") return null;
// A gift never speaks for its recipient or replaces their own expression.
const covered = !payload.targetPeerId && !isThrow(payload.reaction) && state.reactions.slice(index + 1).some(next =>
next.payload.kind === "reaction" && !next.payload.targetPeerId && !isThrow(next.payload.reaction) &&
next.sender.peerId === reaction.sender.peerId);
if (covered) return null;
return participants.some(person => person.peerId === reaction.sender.peerId) &&
(!payload.targetPeerId || participants.some(person => person.peerId === payload.targetPeerId)) &&
<RoomReaction key={reaction.id} reaction={reaction} area={area} now={now} />;
});
}