malice

<script lang="ts">

  import { onMount, tick } from 'svelte';

  import { fade, fly } from 'svelte/transition';

  import LoginPanel from './lib/LoginPanel.svelte';

  import MessageRow from './lib/MessageRow.svelte';

  import MentionsInbox from './lib/MentionsInbox.svelte';

  import MxcAvatar from './lib/MxcAvatar.svelte';

  import PinButton from './lib/PinButton.svelte';

  import ThreadPane from './lib/ThreadPane.svelte';

  import Composer from './lib/Composer.svelte';

  import { releaseStaged, stageFiles as stageAttachments, type StagedAttachment, type StickerHandlers } from './lib/staging';

  import RoomThreads from './lib/RoomThreads.svelte';

  import { loadPinnedThreads, openThread, showThread, threadsByRoom } from './lib/threads';

  import { threadMatches } from './lib/thread-index';

  import ContextMenu, { type MenuItem } from './lib/ContextMenu.svelte';

  import PackManager from './lib/PackManager.svelte';

  import PackCloneDialog from './lib/PackCloneDialog.svelte';

  import type { CloneSource } from './lib/pack-clone';

  import { allPacks, findSticker, reactionShortcode } from './lib/packs';

  import { disabledPackImages, loadPackPreferences } from './lib/pack-preferences';

  import { enabledPacks, enabledQuickReactions } from './lib/pack-preferences-model';

  import type { CommandRequest } from './lib/transport';

  import UserCard, { type UserAction } from './lib/UserCard.svelte';

  import { allowed, canRedact, groupMembers, isMuted, parsePowerLevels, type PowerLevels } from './lib/permissions';

  import { moveBefore, pinnedFirst, sortSpaces } from './lib/rail-order';

  import ImageLightbox from './lib/ImageLightbox.svelte';

  import { lightbox } from './lib/lightbox';

  import SecurityPanel from './lib/SecurityPanel.svelte';

  import {

    closeRoom,

    createRoom,

    getEncryption,

    getMembers,

    getProfile,

    getRooms,

    getSession,

    getSpaceChildren,

    fillHistoryGap,

    startRecentHistory,

    joinRoom,

    leaveRoom,

    logout,

    markRead,

    openRoom,

    paginateRoom,

    reactToMessage,

    runCommand,

    sendMessage,

    uploadAttachment,

    uploadAvatar,

    uploadRoomAvatar,

    editMessage

  } from './lib/api';

  import EmojiText from './lib/EmojiText.svelte';

  import { customEmotes, resolveEmotes } from './lib/emotes';

  import { isKnownCommand, parseCommand, splitTarget, unescapeCommand } from './lib/commands';

  import type { ParsedCommand } from './lib/commands';

  import {

    banners,

    blocked,

    connectEvents,

    connection,

    disconnectEvents,

    dismissBanner,

    encryption,

    membersByRoom,

    membersLoading,

    mentionsSnapshot,

    pushBanner,

    imagePacks,

    markTimelineOpened,

    recentHistory,

    resetClientState,

    rooms,

    selectedRoomId,

    sessionUser,

    softLogout,

    timelines,

    pinnedTimelines,

    pinnedTimelineVersions,

    verification

  } from './lib/store';

  import { discardPending, pendingByRoom, queueSend, resetPending, retryPending } from './lib/pending';

  import type { PendingMessage } from './lib/pending';

  import { TimelineViewport } from './lib/timeline-viewport';

  import { mentionsFromHtml, resolveMentions } from './lib/mentions';

  import type { Mention } from './lib/mentions';

  import { loadQuickReactions, quickReactions, saveQuickReactions } from './lib/quick-reactions';

  import { loadKeywords } from './lib/keywords';

  import {

    linkPreviews,

    loadUrlPreviewSettings,

    requestLinkPreview,

    saveUrlPreviewSettings,

    urlPreviewSettings

  } from './lib/link-previews';

  import { notifyTyping, stopTyping } from './lib/typing';

  import { formatDay } from './lib/format';

  import {

    MEMBERS_WIDTH,

    SIDE_WIDTH,

    THREAD_WIDTH,

    lastSpaceRooms,

    lineHeight,

    membersWidth,

    messageSpacing,

    navFolded,

    railFolded,

    sideWidth,

    threadWidth

  } from './lib/appearance';

  import SettingsPanel from './lib/SettingsPanel.svelte';

  import { packsForRoom, parseEncryptionState, parseOwnProfile, parseVerificationState, contentPreview, senderLabel } from './lib/types';

  import type { ImagePack, MemberSummary, OwnProfile, PackImage, Person, QuickReaction, ReplyReference, RoomSummary, SendState, TimelineEvent, TimelineItem } from './lib/types';

  let roomsLoading = false;

  let booted = false;

  let wasOnline = false;

  let search = '';

  let sidebarOpen = false;

  let membersOpen = false;

  let replyingTo: ReplyReference | null = null;

  let dialog: 'join' | 'create' | 'security' | 'settings' | 'packs' | null = null;

  let cloneSource: CloneSource | null = null;

  let joinTarget = '';

  let joinBusy = false;

  let createName = '';

  let createTopic = '';

  let createBusy = false;

  let leaveBusy = false;

  let paginateBusy = false;

  let fillingGaps: Record<string, string> = {};

  let recentRetrying: Record<string, boolean> = {};

  let historyAccount: string | null | undefined;

  $: if ($sessionUser !== historyAccount) {

    historyAccount = $sessionUser;

    fillingGaps = {};

    recentRetrying = {};

  }

  let reacting = false;

  let composer = '';

  let drafts: Record<string, string> = {};

  let stickToBottom = true;

  let timelineEl: HTMLElement | null = null;

  let timelineViewport: TimelineViewport | null = null;

  let composerRef: Composer | null = null;

  let avatarInput: HTMLInputElement | null = null;

  let uploadBusy = false;

  let uploadName: string | null = null;

  let staged: Record<string, StagedAttachment[]> = {};

  let editing: { roomId: string; eventId: string; original: string; stash: string } | null = null;

  /** Everyone picked from the finder per room; only those whose name is still in the text get linked on send. */

  let pickedMentions: Record<string, Mention[]> = {};

  const WARM_ROOM_LIMIT = 8;

  /** Rooms left open after switching away so coming back is instant, least recently viewed first. */

  let warmRooms: string[] = [];

  let openReady: Record<string, boolean> = {};

  let openFailed: Record<string, string> = {};

  let membersFor: string | null = null;

  let lastReadKey = '';

  let readTimer: number | null = null;

  let profile: OwnProfile | null = null;

  let profileMxc: string | null = null;

  let selectedSpaceId: string | null = null;

  let mentionsOpen = false;

  let spaceChildIds: string[] | null = null;

  let spaceChildrenLoading = false;

  let spaceChildrenError: string | null = null;

  let avatarByUser: Record<string, string | null> = {};

  let restoringRoute = false;

  function motionDuration(ms: number): number {

    return typeof window !== 'undefined' && window.matchMedia('(prefers-reduced-motion: reduce)').matches ? 0 : ms;

  }

  // account data is read from the local cache, which is empty on a fresh device until the first sync lands

  $: {

    const online = $connection === 'online';

    if (online && !wasOnline) {

      void loadQuickReactions();

      void loadKeywords();

      void loadPinnedThreads();

      void loadPackPreferences();

      void loadUrlPreviewSettings();

    }

    wasOnline = online;

  }

  $: selectedRoom = $rooms.find((r) => r.room_id === $selectedRoomId) ?? null;

  $: recentState = $selectedRoomId ? $recentHistory[$selectedRoomId] : undefined;

  $: roomPacks = enabledPacks(packsForRoom($imagePacks, $selectedRoomId, $rooms), $disabledPackImages);

  $: roomEmotes = customEmotes(roomPacks);

  $: usableQuickReactions = enabledQuickReactions($quickReactions, allPacks($imagePacks), $disabledPackImages);

  $: previewsAllowed = selectedRoom !== null && (!selectedRoom.encrypted || $urlPreviewSettings.encrypted_rooms);

  $: loadPreview = previewsAllowed && $selectedRoomId ? previewLoader($selectedRoomId) : null;

  $: spaceRooms = $rooms.filter((r) => r.space);

  $: spaceParents = parentSpaceMap(spaceRooms);

  $: railSpaces = spaceRooms.filter((s) => !spaceParents.has(s.room_id));

  let railOverride: string[] | null = null;

  $: if (railOverride && sortSpaces(railSpaces, null).map((s) => s.room_id).join() === railOverride.join()) railOverride = null;

  $: orderedRail = sortSpaces(railSpaces, railOverride);

  $: pinnedRail = orderedRail.filter((s) => s.favourite);

  $: otherRail = orderedRail.filter((s) => !s.favourite);

  $: railSelected = selectedSpaceId ? topSpaceOf(selectedSpaceId, spaceParents) : null;

  $: invites = $rooms.filter((r) => r.membership === 'Invited');

  $: query = search.trim().toLowerCase();

  $: selectedSpace = selectedSpaceId ? ($rooms.find((r) => r.room_id === selectedSpaceId) ?? null) : null;

  // While a space's children load (or fail), show no channels rather than the

  // full list — listing everything would falsely imply it belongs to the space.

  $: baseRooms = selectedSpaceId ? (spaceChildIds ? $rooms.filter((r) => spaceChildIds?.includes(r.room_id)) : []) : $rooms;

  $: visibleRooms = query

    ? baseRooms.filter(

        (r) =>

          r.name.toLowerCase().includes(query) ||

          r.room_id.toLowerCase().includes(query) ||

          ($threadsByRoom[r.room_id] ?? []).some((t) => threadMatches(t, query))

      )

    : baseRooms;

  $: directRooms = pinnedFirst(visibleRooms.filter((r) => r.direct && !r.space && r.membership !== 'Invited'));

  $: groupRooms = pinnedFirst(visibleRooms.filter((r) => !r.direct && !r.space && r.membership !== 'Invited'));

  $: spaceList = pinnedFirst(visibleRooms.filter((r) => r.space && r.membership !== 'Invited'));

  $: channelRooms = baseRooms.filter((r) => !r.space && r.membership !== 'Invited');

  $: recoveryBanner = $encryption && ($encryption.recovery === 'Disabled' || $encryption.recovery === 'Incomplete') ? $encryption : null;

  $: verificationBanner = $verification && $verification.kind !== 'Done' ? $verification : null;

  $: items = $selectedRoomId ? ($timelines[$selectedRoomId] ?? []) : [];

  $: currentStaged = $selectedRoomId ? (staged[$selectedRoomId] ?? []) : [];

  $: members = $selectedRoomId ? ($membersByRoom[$selectedRoomId] ?? []) : [];

  $: memberGroups = groupMembers(members, roomLevels);

  $: people = peopleIn(items, members);

  $: hasStart = items.some((i) => i.kind === 'start');

  $: grouped = buildGroups(items);

  $: lastSentId = lastOwnSent(items);

  $: pendingItems = $selectedRoomId ? ($pendingByRoom[$selectedRoomId] ?? []) : [];

  $: lastRealOwn = lastSenderIsOwn(items);

  function lastSenderIsOwn(list: TimelineItem[]): boolean {

    for (let i = list.length - 1; i >= 0; i -= 1) {

      const it = list[i];

      if (it.kind === 'event') return it.event.sender.user_id === $sessionUser;

    }

    return false;

  }

  function pendingShowSender(index: number): boolean {

    return index === 0 ? !lastRealOwn : false;

  }

  function pendingToEvent(p: PendingMessage): TimelineEvent {

    const state: SendState = p.status === 'failed' ? { kind: 'Failed', will_retry: false } : { kind: 'Sending' };

    return {

      item_id: `pending-${p.id}`,

      event_id: null,

      transaction_id: p.id,

      sender: {

        user_id: $sessionUser ?? '',

        display_name: profile?.display_name ?? null,

        avatar: null,

        name_ambiguous: false

      },

      timestamp_ms: p.createdAt,

      own: true,

      send_state: state,

      content: {

        kind: 'Message',

        message: { kind: 'Text', body: p.body, geo_uri: null, formatted_body: p.formatted, edited: false, media: null, link_previews: [] }

      },

      reply_to: p.replyTo,

      thread_root: null,

      thread_summary: null,

      reactions: [],

      read_by: [],

      editable: false

    };

  }

  interface Group {

    key: string;

    item: TimelineItem;

    showSender: boolean;

  }

  function lastOwnSent(list: TimelineItem[]): string | null {

    for (let i = list.length - 1; i >= 0; i--) {

      const item = list[i];

      if (item.kind === 'event' && item.event.own && item.event.send_state.kind === 'Sent') return item.event.item_id;

    }

    return null;

  }

  function buildGroups(list: TimelineItem[]): Group[] {

    const out: Group[] = [];

    let prevSender: string | null = null;

    let prevTs = 0;

    list.forEach((item, index) => {

      let showSender = true;

      if (item.kind === 'event') {

        const e = item.event;

        showSender =

          prevSender !== e.sender.user_id || Math.abs(e.timestamp_ms - prevTs) > 5 * 60 * 1000;

        prevSender = e.sender.user_id;

        prevTs = e.timestamp_ms;

        out.push({ key: e.item_id || e.event_id || `m-${index}`, item, showSender });

      } else {

        prevSender = null;

        const key = item.kind === 'historyGap' ? `gap-${item.gap.id}` : `${item.kind}-${index}`;

        out.push({ key, item, showSender });

      }

    });

    return out;

  }

  function roomUnread(r: RoomSummary): number {

    return r.unread_messages + r.unread_mentions;

  }

  function recordRoute(spaceId: string | null, roomId: string | null, view?: string): void {

    if (restoringRoute) return;

    const url = new URL(window.location.href);

    url.searchParams.delete('space');

    url.searchParams.delete('room');

    url.searchParams.delete('view');

    if (view) url.searchParams.set('view', view);

    if (spaceId) url.searchParams.set('space', spaceId);

    if (roomId) url.searchParams.set('room', roomId);

    const next = `${url.pathname}${url.search}${url.hash}`;

    const current = `${window.location.pathname}${window.location.search}${window.location.hash}`;

    if (next !== current) window.history.pushState({ spaceId, roomId }, '', next);

  }

  async function restoreRoute(): Promise<void> {

    const url = new URL(window.location.href);

    const roomId = url.searchParams.get('room');

    const spaceId = url.searchParams.get('space');

    restoringRoute = true;

    try {

      if (url.searchParams.get('view') === 'mentions') {

        selectMentions();

      } else if (roomId && $rooms.some((room) => room.room_id === roomId && !room.space)) {

        selectedSpaceId = spaceId && $rooms.some((room) => room.room_id === spaceId && room.space) ? spaceId : null;

        spaceChildrenError = null;

        spaceChildIds = selectedSpaceId ? (await getSpaceChildren(selectedSpaceId)).room_ids ?? [] : null;

        await selectRoom(roomId);

      } else if (spaceId && $rooms.some((room) => room.room_id === spaceId && room.space)) {

        await selectSpace(spaceId);

      } else {

        await selectHome();

      }

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Could not restore navigation');

    } finally {

      restoringRoute = false;

    }

  }

  function isEditable(target: EventTarget | null): boolean {

    if (!(target instanceof HTMLElement)) return false;

    return target instanceof HTMLTextAreaElement || target instanceof HTMLInputElement || target.isContentEditable;

  }

  onMount(() => {

    const onPopState = () => void restoreRoute();

    const onAttention = () => queueReadReceipt();

    const hidePointer = (e: KeyboardEvent) => {

      if (e.ctrlKey || e.metaKey || e.altKey || !isEditable(e.target)) return;

      if (e.key.length === 1 || e.key === 'Backspace' || e.key === 'Delete' || e.key === 'Enter') {

        document.documentElement.classList.add('pointer-hidden');

      }

    };

    const showPointer = () => document.documentElement.classList.remove('pointer-hidden');

    const movePointer = (e: PointerEvent) => {

      if (e.movementX !== 0 || e.movementY !== 0) showPointer();

    };

    window.addEventListener('popstate', onPopState);

    window.addEventListener('focus', onAttention);

    document.addEventListener('visibilitychange', onAttention);

    window.addEventListener('keydown', hidePointer, true);

    window.addEventListener('pointermove', movePointer);

    window.addEventListener('pointerdown', showPointer);

    void boot();

    return () => {

      window.removeEventListener('popstate', onPopState);

      window.removeEventListener('focus', onAttention);

      document.removeEventListener('visibilitychange', onAttention);

      window.removeEventListener('keydown', hidePointer, true);

      window.removeEventListener('pointermove', movePointer);

      window.removeEventListener('pointerdown', showPointer);

      showPointer();

      disconnectEvents();

      stopTyping();

      if (readTimer !== null) window.clearTimeout(readTimer);

    };

  });

  async function boot(): Promise<void> {

    try {

      const session = await getSession();

      blocked.set(session.blocked ?? false);

      sessionUser.set(session.user_id);

      if (session.user_id) {

        softLogout.set(null);

        await refreshRooms();

        await restoreRoute();

        connectEvents();

        void loadProfile();

        void loadEncryption();

        void loadQuickReactions();

        void loadKeywords();

        void loadPinnedThreads();

        void loadPackPreferences();

        void loadUrlPreviewSettings();

      } else {

        softLogout.set(session.soft_logout ?? null);

      }

    } catch (e) {

      pushBanner(e instanceof Error ? `Session check failed: ${e.message}` : 'Session check failed');

      sessionUser.set(null);

    } finally {

      booted = true;

    }

  }

  async function refreshRooms(): Promise<void> {

    roomsLoading = true;

    try {

      const res = await getRooms();

      rooms.set(res.rooms);

      pruneSpaceFilter();

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Could not load rooms');

    } finally {

      roomsLoading = false;

    }

  }

  async function loadProfile(): Promise<void> {

    try {

      const raw = await getProfile();

      profile = parseOwnProfile(raw);

      profileMxc = profile.avatar_url;

    } catch {

      profile = null;

    }

  }

  async function loadEncryption(): Promise<void> {

    try {

      const res = await getEncryption();

      const state = parseEncryptionState(res.state);

      if (state) encryption.set(state);

      const verificationState = parseVerificationState(res.verification);

      if (verificationState) verification.set(verificationState);

    } catch {

      // Encryption status also arrives over SSE; a failed first fetch is not fatal.

    }

  }

  function afterLogin(userId: string): void {

    sessionUser.set(userId);

    softLogout.set(null);

    blocked.set(false);

    void refreshRooms();

    connectEvents();

    void loadProfile();

    void loadEncryption();

    void loadQuickReactions();

    void loadKeywords();

    void loadPinnedThreads();

    void loadPackPreferences();

    void loadUrlPreviewSettings();

  }

  async function doLogout(): Promise<void> {

    stopTyping();

    try {

      await logout();

    } catch (e) {

      pushBanner(e instanceof Error ? e.message : 'Logout failed');

      return;

    }

    disconnectEvents();

    resetClientState();

    softLogout.set(null);

    blocked.set(false);

    sessionUser.set(null);

    lightbox.set(null);

    composer = '';

    drafts = {};

    dialog = null;

    cloneSource = null;

    membersOpen = false;

    sidebarOpen = false;

    profile = null;

    profileMxc = null;

    mentionsOpen = false;

    selectedSpaceId = null;

    spaceChildIds = null;

    spaceChildrenError = null;

    openReady = {};

    openFailed = {};

    warmRooms = [];

    pickedMentions = {};

    composerRef?.closeFinders();

    clearAllStaged();

    avatarByUser = {};

    resetPending();

  }

  /** Joined spaces that sit inside another joined space, keyed to one such parent. Either side of the link counts. */

  function parentSpaceMap(spaces: RoomSummary[]): Map<string, string> {

    const ids = new Set(spaces.map((s) => s.room_id));

    const parents = new Map<string, string>();

    for (const space of spaces) {

      for (const child of space.children) {

        if (child !== space.room_id && ids.has(child) && !parents.has(child)) parents.set(child, space.room_id);

      }

    }

    for (const space of spaces) {

      const parent = space.parent_spaces.find((id) => id !== space.room_id && ids.has(id));

      if (parent && !parents.has(space.room_id)) parents.set(space.room_id, parent);

    }

    for (const id of [...parents.keys()]) {

      const seen = new Set<string>([id]);

      let at = parents.get(id);

      while (at && !seen.has(at)) {

        seen.add(at);

        at = parents.get(at);

      }

      if (at) parents.delete(id);

    }

    return parents;

  }

  function topSpaceOf(id: string, parents: Map<string, string>): string {

    let at = id;

    while (parents.has(at)) at = parents.get(at)!;

    return at;

  }

  function pruneSpaceFilter(): void {

    if (!selectedSpaceId) return;

    if (!$rooms.some((r) => r.room_id === selectedSpaceId)) {

      selectedSpaceId = null;

      spaceChildIds = null;

      spaceChildrenError = null;

    }

  }

  async function selectHome(): Promise<void> {

    mentionsOpen = false;

    selectedSpaceId = null;

    spaceChildIds = null;

    spaceChildrenError = null;

    if (window.innerWidth > 640) navFolded.set(false);

    sidebarOpen = true;

    recordRoute(null, null);

  }

  function stashDraft(): void {

    const roomId = $selectedRoomId;

    if (!roomId) return;

    if (composer.trim()) drafts[roomId] = composer;

    else delete drafts[roomId];

  }

  function selectMentions(): void {

    stashDraft();

    stopTyping();

    selectedSpaceId = null;

    spaceChildIds = null;

    spaceChildrenError = null;

    spaceChildrenLoading = false;

    selectedRoomId.set(null);

    replyingTo = null;

    editing = null;

    composerRef?.closeFinders();

    peeking = null;

    membersOpen = false;

    sidebarOpen = false;

    mentionsOpen = true;

    recordRoute(null, null, 'mentions');

  }

  function toggleChannelsPane(): void {

    if (window.innerWidth <= 640) sidebarOpen = !sidebarOpen;

    else navFolded.update((v) => !v);

  }

  async function selectSpace(spaceId: string): Promise<void> {

    mentionsOpen = false;

    stashDraft();

    stopTyping();

    selectedSpaceId = spaceId;

    spaceChildIds = null;

    spaceChildrenError = null;

    spaceChildrenLoading = true;

    const last = $lastSpaceRooms[spaceId];

    const resume = last && $rooms.some((r) => r.room_id === last && !r.space) ? last : null;

    if (resume) {

      void selectRoom(resume);

    } else {

      selectedRoomId.set(null);

    }

    try {

      const res = await getSpaceChildren(spaceId);

      if (selectedSpaceId === spaceId) {

        spaceChildIds = res.room_ids ?? [];

        const firstChannel = spaceChildIds

          .map((id) => $rooms.find((room) => room.room_id === id))

          .find((room) => room && !room.space);

        if ((!resume || !spaceChildIds.includes(resume)) && firstChannel) {

          await selectRoom(firstChannel.room_id);

        }

      }

    } catch (e) {

      if (selectedSpaceId === spaceId) {

        spaceChildrenError = e instanceof Error ? e.message : 'Could not load rooms in this space';

        spaceChildIds = [];

      }

    } finally {

      if (selectedSpaceId === spaceId) spaceChildrenLoading = false;

    }

  }

  async function selectRoom(roomId: string, peek = false): Promise<void> {

    mentionsOpen = false;

    peeking = peek ? roomId : null;

    stashDraft();

    if (roomId === $selectedRoomId && openReady[roomId]) {

      sidebarOpen = false;

      return;

    }

    stopTyping();

    const spaceId = selectedSpaceId;

    if (spaceId) lastSpaceRooms.update((all) => ({ ...all, [spaceId]: roomId }));

    selectedRoomId.set(roomId);

    recordRoute(selectedSpaceId, roomId);

    composer = drafts[roomId] ?? '';

    replyingTo = null;

    editing = null;

    composerRef?.closeFinders();

    stickToBottom = true;

    lastReadKey = '';

    sidebarOpen = false;

    touchWarmRoom(roomId);

    if (openReady[roomId]) {

      if (membersOpen) void loadMembers(roomId);

      await tick();

      scrollToBottom();

      queueReadReceipt();

      composerRef?.focus();

      return;

    }

    if (openFailed[roomId]) {

      const nextFailed = { ...openFailed };

      delete nextFailed[roomId];

      openFailed = nextFailed;

    }

    try {