Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

18.9 KB
Raw Blame
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} />;
  });
}