Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

20.5 KB
Raw Blame
import ClipboardJS from "clipboard";
import {$} from "jquery";
import _ from "lodash";
import assert from "minimalistic-assert";

import render_banner from "../templates/components/banner.hbs";
import render_draft_table_body from "../templates/draft_table_body.hbs";
import render_drafts_list from "../templates/drafts_list.hbs";

import * as browser_history from "./browser_history.ts";
import * as channel from "./channel.ts";
import * as compose_actions from "./compose_actions.ts";
import {show_copied_confirmation} from "./copied_tooltip.ts";
import type {FormattedDraft, LocalStorageDraft} from "./drafts.ts";
import * as drafts from "./drafts.ts";
import {$t} from "./i18n.ts";
import * as markdown from "./markdown.ts";
import {message_render_response_schema} from "./message_store.ts";
import * as message_view from "./message_view.ts";
import * as messages_overlay_ui from "./messages_overlay_ui.ts";
import * as mouse_drag from "./mouse_drag.ts";
import * as overlay_util from "./overlay_util.ts";
import * as overlays from "./overlays.ts";
import * as people from "./people.ts";
import {postprocess_content} from "./postprocess_content.ts";
import * as rendered_markdown from "./rendered_markdown.ts";
import * as stream_data from "./stream_data.ts";
import type {StreamSubscription} from "./sub_store.ts";
import * as user_card_popover from "./user_card_popover.ts";
import * as user_group_popover from "./user_group_popover.ts";

let draft_undo_delete_list: LocalStorageDraft[] = [];

function clear_undo_list(): void {
    draft_undo_delete_list = [];
    $("#draft_overlay_banner_container").empty();
}

function undo_draft_deletion(): void {
    if (draft_undo_delete_list.length === 0) {
        return;
    }

    for (const draft of draft_undo_delete_list) {
        drafts.draft_model.addDraft(draft);
    }

    clear_undo_list();
    rerender_drafts();

    $(".select-drafts-button").show();
    $(".delete-selected-drafts-button").show();
}

function show_delete_banner(): void {
    const $banner_container = $("#draft_overlay_banner_container");
    $banner_container.empty();
    const banner_html = render_banner({
        intent: "success",
        label: $t(
            {
                defaultMessage:
                    "{N, plural, one {# draft was deleted.} other {# drafts were deleted.}}",
            },
            {N: draft_undo_delete_list.length},
        ),
        buttons: [
            {
                variant: "subtle",
                intent: "success",
                label: $t({defaultMessage: "Undo"}),
                custom_classes: "draft-delete-banner-undo-button",
            },
        ],
        close_button: true,
    });

    $banner_container.html(banner_html);
}

function restore_draft(draft_id: string): void {
    const draft = drafts.draft_model.getDraft(draft_id);
    if (!draft) {
        return;
    }

    const compose_args = {...drafts.restore_message(draft), draft_id};

    if (compose_args.type === "stream") {
        if (
            compose_args.stream_id !== undefined &&
            (compose_args.topic !== "" || stream_data.can_use_empty_topic(compose_args.stream_id))
        ) {
            message_view.show(
                [
                    {
                        operator: "channel",
                        operand: compose_args.stream_id.toString(),
                    },
                    {operator: "topic", operand: compose_args.topic},
                ],
                {trigger: "restore draft"},
            );
        }
    } else {
        if (compose_args.private_message_recipient_ids.length > 0) {
            message_view.show(
                [{operator: "dm", operand: compose_args.private_message_recipient_ids}],
                {
                    trigger: "restore draft",
                },
            );
        }
    }

    overlays.close_overlay("drafts");
    compose_actions.start({
        ...compose_args,
        message_type: compose_args.type,
    });
}

function remove_drafts($draft_rows: JQuery): void {
    // Deletes the drafts and removes it from the list
    const deleted_drafts: LocalStorageDraft[] = [];
    const draft_ids: string[] = [];

    $draft_rows.each(function () {
        const draft_id = $(this).attr("data-draft-id")!;

        const draft = drafts.draft_model.getDraft(draft_id);
        if (draft) {
            deleted_drafts.push(draft);
            draft_ids.push(draft_id);
            $(this).remove();
        }
    });

    if (deleted_drafts.length > 0) {
        drafts.draft_model.deleteDrafts(draft_ids);
        draft_undo_delete_list.push(...deleted_drafts);
        show_delete_banner();
    }

    if ($(".drafts-tab-pane .overlay-message-row").length === 0) {
        $(".drafts-tab-pane .no-drafts").show();
    }
    update_rendered_drafts(
        $("#drafts-from-conversation .overlay-message-row").length > 0,
        $("#other-drafts .overlay-message-row").length > 0,
    );
}

function update_rendered_drafts(
    has_drafts_from_conversation: boolean,
    has_other_drafts: boolean,
): void {
    if (has_drafts_from_conversation) {
        $("#drafts-from-conversation").show();
    } else {
        // Since there are no relevant drafts from this conversation left, switch to the "all drafts" view and remove headers.
        $("#drafts-from-conversation").hide();
        $("#other-drafts-header").hide();
    }

    if (!has_other_drafts) {
        $("#other-drafts").hide();
    }
}

const keyboard_handling_context: messages_overlay_ui.Context = {
    get_items_ids() {
        const draft_ids: string[] = [];
        for (const row of document.querySelectorAll<HTMLElement>(
            ".drafts-tab-pane .overlay-message-row",
        )) {
            const id = row.dataset["draftId"];
            assert(id !== undefined);
            draft_ids.push(id);
        }
        return draft_ids;
    },
    on_enter() {
        // This handles when pressing Enter while looking at drafts.
        // It restores draft that is focused.
        const draft_id_arrow = this.get_items_ids();

        if (draft_id_arrow.length === 0) {
            // Do nothing if there are no drafts.
            return;
        }

        const focused_draft_id = messages_overlay_ui.get_focused_element_id(this);
        if (focused_draft_id !== undefined) {
            restore_draft(focused_draft_id);
        } else {
            const first_draft = draft_id_arrow.at(0);
            assert(first_draft !== undefined);
            restore_draft(first_draft);
        }
    },
    on_delete() {
        // Allows user to delete drafts with Backspace
        const focused_element_id = messages_overlay_ui.get_focused_element_id(this);
        if (focused_element_id === undefined) {
            return;
        }
        const $focused_row = messages_overlay_ui.row_with_focus(this);
        messages_overlay_ui.focus_on_sibling_element(this);
        remove_drafts($focused_row);
    },
    items_container_selector: "drafts-container",
    items_list_selector: "drafts-list",
    row_item_selector: "draft-message-row",
    box_item_selector: "draft-message-info-box",
    id_attribute_name: "data-draft-id",
};

export function handle_keyboard_events(event_key: string): void {
    messages_overlay_ui.modals_handle_events(event_key, keyboard_handling_context);
}

function format_drafts(data: Record<string, LocalStorageDraft>): FormattedDraft[] {
    const sorted_raw_drafts = Object.entries(data).map(([id, draft]) => ({...draft, id}));
    sorted_raw_drafts.sort((draft_a, draft_b) => draft_b.updatedAt - draft_a.updatedAt);

    const sorted_formatted_drafts = sorted_raw_drafts
        .map((draft_row) => drafts.format_draft(draft_row))
        .filter((formatted_draft) => formatted_draft !== undefined);

    return sorted_formatted_drafts;
}

type NarrowDraftsHeaderContext = {
    is_dm_with_self?: boolean;
    dm_recipient_string?: string;
    stream?: StreamSubscription | undefined;
    channel_name_fallback?: string | undefined;
    topic?: string | undefined;
};

function get_header_context_for_narrow_drafts(): NarrowDraftsHeaderContext {
    const {stream_name, topic, private_recipient_ids} = drafts.current_recipient_data();
    if (private_recipient_ids && private_recipient_ids.length > 0) {
        if (private_recipient_ids.length === 1) {
            const user = people.get_by_user_id(private_recipient_ids[0]!);
            if (user && people.is_direct_message_conversation_with_self([user.user_id])) {
                return {is_dm_with_self: true};
            }
        }
        return {
            dm_recipient_string: people.user_ids_to_full_names_string(private_recipient_ids),
        };
    }
    const stream = stream_name ? stream_data.get_sub_by_name(stream_name) : undefined;
    return {
        stream,
        channel_name_fallback: stream_name,
        topic,
    };
}

function get_formatted_drafts_data(): {
    narrow_drafts: FormattedDraft[];
    other_drafts: FormattedDraft[];
    narrow_drafts_header: NarrowDraftsHeaderContext;
} {
    const all_drafts = drafts.draft_model.get();
    const narrow_drafts_raw = drafts.filter_drafts_by_compose_box_and_recipient(all_drafts);
    const other_drafts_raw = _.pick(
        all_drafts,
        _.difference(Object.keys(all_drafts), Object.keys(narrow_drafts_raw)),
    );
    const narrow_drafts = format_drafts(narrow_drafts_raw);
    const other_drafts = format_drafts(other_drafts_raw);
    const narrow_drafts_header = get_header_context_for_narrow_drafts();
    return {narrow_drafts, other_drafts, narrow_drafts_header};
}

function fetch_server_rendered_drafts(formatted_drafts: FormattedDraft[]): void {
    // compose_ui.ts does thumbnail polling to check for thumbnails for recently
    // uploaded images. We don't want to do that here since there will always
    // be some time delta between writing a message and seeing the draft overlay
    // for it.
    for (const draft of formatted_drafts) {
        if (markdown.contains_backend_only_syntax(draft.raw_content)) {
            void channel.post({
                url: "/json/messages/render",
                data: {content: draft.raw_content},
                success(response_data) {
                    if (!overlays.drafts_open()) {
                        return;
                    }
                    const data = message_render_response_schema.parse(response_data);
                    const $content_element = $(
                        `[data-draft-id="${CSS.escape(draft.draft_id)}"] .message_content`,
                    );
                    if ($content_element.length === 0) {
                        return;
                    }
                    $content_element.html(postprocess_content(data.rendered));
                    rendered_markdown.update_elements($content_element);
                },
                // We don't do anything on error and keep displaying the
                // locally rendered message.
            });
        }
    }
}

function render_widgets(
    narrow_drafts: FormattedDraft[],
    other_drafts: FormattedDraft[],
    narrow_drafts_header: NarrowDraftsHeaderContext,
): void {
    const $drafts_table = $("#drafts_table");
    if ($(".drafts-list").length === 0) {
        const rendered = render_draft_table_body({
            context: {
                narrow_drafts_header,
                narrow_drafts,
                other_drafts,
            },
        });
        $drafts_table.append($(rendered));
    } else {
        const rendered = render_drafts_list({
            narrow_drafts_header,
            narrow_drafts,
            other_drafts,
        });
        $(".drafts-list").replaceWith($(rendered));
    }
    if ($(".drafts-tab-pane .overlay-message-row").length > 0) {
        $(".drafts-tab-pane .no-drafts").hide();
        // Update possible dynamic elements.
        const $rendered_drafts = $drafts_table.find(
            ".message_content.rendered_markdown.restore-overlay-message",
        );
        $rendered_drafts.each(function () {
            rendered_markdown.update_elements($(this));
        });
    }
    update_rendered_drafts(narrow_drafts.length > 0, other_drafts.length > 0);
    update_bulk_delete_ui();
    fetch_server_rendered_drafts([...narrow_drafts, ...other_drafts]);
}

function setup_event_handlers(): void {
    $("#drafts_table .restore-overlay-message").on("click", function (e) {
        if (
            mouse_drag.is_drag(e) ||
            messages_overlay_ui.handle_overlay_media_click(
                e,
                "drafts",
                keyboard_handling_context,
                () => {
                    browser_history.go_to_location("#drafts");
                },
            )
        ) {
            return;
        }

        e.stopPropagation();

        const $draft_row = $(this).closest(".overlay-message-row");
        const draft_id = $draft_row.attr("data-draft-id")!;
        restore_draft(draft_id);
    });

    $("#drafts_table .restore-overlay-message").on(
        "click",
        ".user-mention",
        user_card_popover.unsaved_message_user_mention_event_handler,
    );

    $("#drafts_table .restore-overlay-message").on(
        "click",
        ".user-group-mention",
        function (this: HTMLElement, e) {
            // We stop the event from propagating because that is what
            // the main `.messagebox .user-group-mention` click handler
            // expects us to do for drafts.
            e.stopPropagation();
            if (mouse_drag.is_drag(e)) {
                return;
            }

            user_group_popover.toggle_user_group_info_popover(this, undefined);
        },
    );

    $("#drafts_table .overlay_message_controls .delete-overlay-message").on("click", function () {
        const $draft_row = $(this).closest(".overlay-message-row");

        remove_drafts($draft_row);
        update_bulk_delete_ui();
    });

    $("#drafts_table .overlay_message_controls .draft-selection-checkbox").on("click", (e) => {
        const is_checked = is_checkbox_icon_checked($(e.target));
        toggle_checkbox_icon_state($(e.target), !is_checked);
        update_bulk_delete_ui();
    });
}

function setup_bulk_actions_handlers(): void {
    $(".select-drafts-button").on("click", (e) => {
        e.preventDefault();
        const $unchecked_checkboxes = $(".draft-selection-checkbox").filter(function () {
            return !is_checkbox_icon_checked($(this));
        });
        const check_boxes = $unchecked_checkboxes.length > 0;
        $(".draft-selection-checkbox").each(function () {
            toggle_checkbox_icon_state($(this), check_boxes);
        });
        update_bulk_delete_ui();
    });

    $(".delete-selected-drafts-button").on("click", () => {
        const $selected_rows = $(".drafts-list")
            .find(".draft-selection-checkbox.fa-check-square")
            .closest(".overlay-message-row");
        remove_drafts($selected_rows);
        update_bulk_delete_ui();
    });
}

function rerender_drafts(): void {
    const {narrow_drafts, other_drafts, narrow_drafts_header} = get_formatted_drafts_data();
    render_widgets(narrow_drafts, other_drafts, narrow_drafts_header);
    setup_event_handlers();
}

export function launch(): void {
    const {narrow_drafts, other_drafts, narrow_drafts_header} = get_formatted_drafts_data();

    $("#drafts_table").empty();
    render_widgets(narrow_drafts, other_drafts, narrow_drafts_header);

    // We need to force a style calculation on the newly created
    // element in order for the CSS transition to take effect.
    $("#draft_overlay").css("opacity");

    open_overlay();
    const restore_id = messages_overlay_ui.get_and_clear_pending_restore_element_id();
    if (
        restore_id === undefined ||
        !messages_overlay_ui.try_set_initial_element(restore_id, keyboard_handling_context)
    ) {
        const first_element_id = [...narrow_drafts, ...other_drafts][0]?.draft_id;
        // Delay focus initialization until the overlay DOM is fully rendered.
        // Otherwise, get_focused_element_id() returns undefined and the focus
        // may not be applied.
        setTimeout(() => {
            messages_overlay_ui.set_initial_element(first_element_id, keyboard_handling_context);
        }, 0);
    }
    setup_event_handlers();
    setup_bulk_actions_handlers();
}

export function update_bulk_delete_ui(): void {
    const $unchecked_checkboxes = $(".draft-selection-checkbox").filter(function () {
        return !is_checkbox_icon_checked($(this));
    });
    const $checked_checkboxes = $(".draft-selection-checkbox").filter(function () {
        return is_checkbox_icon_checked($(this));
    });
    const $select_drafts_button = $(".select-drafts-button");
    const $select_state_indicator = $(".select-drafts-button .select-state-indicator");
    const $delete_selected_drafts_button = $(".delete-selected-drafts-button");

    if ($checked_checkboxes.length > 0) {
        $delete_selected_drafts_button.prop("disabled", false);
        if ($unchecked_checkboxes.length === 0) {
            toggle_checkbox_icon_state($select_state_indicator, true);
        } else {
            toggle_checkbox_icon_state($select_state_indicator, false);
        }
    } else {
        if ($unchecked_checkboxes.length > 0) {
            toggle_checkbox_icon_state($select_state_indicator, false);
            $delete_selected_drafts_button.prop("disabled", true);
        } else {
            $select_drafts_button.hide();
            $delete_selected_drafts_button.hide();
        }
    }
}

export function open_overlay(): void {
    drafts.sync_count();
    overlays.open_overlay({
        name: "drafts",
        $overlay: $("#draft_overlay"),
        on_close() {
            browser_history.exit_overlay();
            drafts.sync_count();
            draft_undo_delete_list = [];
        },
    });
}

export function is_checkbox_icon_checked($checkbox: JQuery): boolean {
    return $checkbox.hasClass("fa-check-square");
}

export function toggle_checkbox_icon_state($checkbox: JQuery, checked: boolean): void {
    $checkbox.parent().attr("aria-checked", checked.toString());
    if (checked) {
        $checkbox.removeClass("fa-square-o").addClass("fa-check-square");
    } else {
        $checkbox.removeClass("fa-check-square").addClass("fa-square-o");
    }
}

export function initialize(): void {
    new ClipboardJS("#drafts_table .overlay_message_controls .copy-overlay-message", {
        text(trigger): string {
            const draft_id = $(trigger).attr("data-draft-id")!;
            const draft = drafts.draft_model.getDraft(draft_id);
            if (!draft) {
                return "";
            }
            return draft.content ?? "";
        },
    }).on("success", (e) => {
        show_copied_confirmation(e.trigger, {
            show_check_icon: true,
        });
    });

    $("body").on("focus", "#draft_overlay", (e) => {
        if (!(e.target instanceof HTMLElement)) {
            return;
        }
        const draft_row = e.target.closest(".overlay-message-info-box");
        if (draft_row instanceof HTMLElement) {
            // A draft gained focus; mark it as the selected draft.
            messages_overlay_ui.activate_element(draft_row, keyboard_handling_context);
        } else if (e.target.matches(overlay_util.OVERLAY_FOCUSABLE_SELECTOR)) {
            // Another focusable element (e.g. a header button) gained focus;
            // draft info-boxes are already handled by the branch above, so
            // the `.overlay-message-info-box` part of the selector never
            // matches here.
            // Only clear the draft selection when the control was reached via
            // keyboard (Tab), where both it and the draft would show a focus
            // ring; a pointer click shows no ring on the control, so keep the
            // selection.
            if (e.target.matches(":focus-visible")) {
                $("#drafts_table .overlay-message-info-box").removeClass("active");
            }
        } else {
            // Focus landed on a non-interactive area. Return focus to the
            // selected draft or the first one if none is selected, so that
            // keyboard navigation continues from a draft.
            const draft_to_focus =
                $("#drafts_table .overlay-message-info-box.active")[0] ??
                $("#drafts_table .overlay-message-info-box")[0];
            if (draft_to_focus !== undefined) {
                messages_overlay_ui.activate_element(draft_to_focus, keyboard_handling_context);
            }
        }
    });
    $("body").on(
        "click",
        "#draft_overlay_banner_container .draft-delete-banner-undo-button",
        undo_draft_deletion,
    );
    $("body").on("click", "#draft_overlay_banner_container .banner-close-button", clear_undo_list);
}