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.

list_widget: Remove rows of items dropped from the list on resort.

Aman Agrawal99359f16d7f6
diff --git a/web/src/list_widget.ts b/web/src/list_widget.ts
index 2264bb93477..33b14411feb 100644
--- a/web/src/list_widget.ts
+++ b/web/src/list_widget.ts
@@ -72,7 +72,7 @@ type BaseListWidget = {
export type ListWidget<Key, Item = Key> = BaseListWidget & {
get_current_list: () => Item[];
get_rendered_list: () => Item[];
- filter_and_sort: () => void;
+ filter_and_sort: () => Item[];
retain_selected_items: () => void;
all_rendered: () => boolean;
render: (how_many?: number) => void;
@@ -84,7 +84,6 @@ export type ListWidget<Key, Item = Key> = BaseListWidget & {
set_up_event_handlers: () => void;
increase_rendered_offset: () => void;
reduce_rendered_offset: () => void;
- remove_rendered_row: (row: JQuery) => void;
clean_redraw: () => void;
hard_redraw: () => void;
insert_rendered_row: (
@@ -356,8 +355,39 @@ export function create<Key, Item = Key>(
return meta.filtered_list.slice(0, meta.offset);
},
+ // Recomputes the filtered list and removes the rendered rows of
+ // items it no longer includes, returning those items. A row left
+ // behind would not be counted by meta.offset, so a later render()
+ // would append rows that are already on screen. The removed rows
+ // are expected to belong to items the caller is updating;
+ // returning them lets the caller report any other item, hidden by
+ // a change it was not told about.
filter_and_sort() {
+ const previously_rendered_items = widget.get_rendered_list();
compute_filtered_list();
+ if (!opts.html_selector || previously_rendered_items.length === 0) {
+ return [];
+ }
+
+ const listed_items = new Set(meta.filtered_list);
+ const removed_items: Item[] = [];
+ for (const item of previously_rendered_items) {
+ if (listed_items.has(item)) {
+ continue;
+ }
+ const $row = opts.html_selector(item);
+ if ($row.length === 0) {
+ continue;
+ }
+ $row.remove();
+ widget.reduce_rendered_offset();
+ removed_items.push(item);
+ }
+ if (removed_items.length > 0 && widget.all_rendered()) {
+ // render() shows the empty-list message once the last row is gone.
+ widget.render();
+ }
+ return removed_items;
},
// Used in case of Multiselect DropdownListWidget to retain
@@ -561,17 +591,6 @@ export function create<Key, Item = Key>(
meta.offset = Math.max(meta.offset - 1, 0);
},
- remove_rendered_row(rendered_row) {
- rendered_row.remove();
- // We removed a rendered row, so we need to reduce one offset.
- widget.reduce_rendered_offset();
- // If the container is now empty, render() will display
- // the empty-list message.
- if (this.all_rendered()) {
- this.render();
- }
- },
-
clean_redraw() {
compute_filtered_list();
widget.clear();
diff --git a/web/src/recent_view_ui.ts b/web/src/recent_view_ui.ts
index e22ce7a5cef..195944159ab 100644
--- a/web/src/recent_view_ui.ts
+++ b/web/src/recent_view_ui.ts
@@ -1142,6 +1142,22 @@ export function filters_should_hide_row(topic_data: ConversationData): boolean {
return false;
}
+// Recomputes the widget's filtered list, keeping keyboard focus
+// sensible when the resort removed the focused row.
+function filter_and_sort_topics_widget(): void {
+ assert(topics_widget !== undefined);
+ // Look up the focused row while row_focus still indexes the rows the
+ // resort may remove.
+ const focused_message_id = get_focused_row_message()?.id;
+ const removed_conversations = topics_widget.filter_and_sort();
+ const focused_row_removed = removed_conversations.some(
+ (conversation) => conversation.last_msg_id === focused_message_id,
+ );
+ if (focused_row_removed && row_focus >= topics_widget.get_current_list().length) {
+ row_focus = Math.max(topics_widget.get_current_list().length - 1, 0);
+ }
+}
+
export function bulk_inplace_rerender(row_keys: string[]): void {
if (!topics_widget || !recent_view_util.is_visible()) {
return;
@@ -1155,7 +1171,7 @@ export function bulk_inplace_rerender(row_keys: string[]): void {
// so we know if it's safe to use render() for new items below.
const was_all_rendered = topics_widget.all_rendered();
topics_widget.replace_list_data(get_list_data_for_widget(), false);
- topics_widget.filter_and_sort();
+ filter_and_sort_topics_widget();
// Iterate in the order in which the rows should be present so that
// we are not inserting rows without any rows being present around them.
let processed_count = 0;
@@ -1199,38 +1215,21 @@ export let inplace_rerender = (topic_key: string, is_bulk_rerender?: boolean): b
//
// NOTE: This doesn't add any new entry to the original list but updates the filtered list
// based on the current filters and updated row data.
- topics_widget.filter_and_sort();
+ filter_and_sort_topics_widget();
}
// We cannot rely on `topic_widget.meta.filtered_list` to know
// if a topic is rendered since the `filtered_list` might have
// already been updated via other calls.
- const $topic_row = get_topic_row(topic_data);
- const is_topic_rendered = $topic_row.length;
+ const is_topic_rendered = get_topic_row(topic_data).length > 0;
const current_topics_list = topics_widget.get_current_list();
- if (is_topic_rendered && filters_should_hide_row(topic_data)) {
- // Since the row needs to be removed from DOM, we need to adjust `row_focus`
- // if the row being removed is focused and is the last row in the list.
- // This prevents the row_focus either being reset to the first row or
- // middle of the visible table rows.
- // We need to get the current focused row details from DOM since we cannot
- // rely on `current_topics_list` since it has already been updated and row
- // doesn't exist inside it.
- const row_is_focused = get_focused_row_message()?.id === topic_data.last_msg_id;
- if (row_is_focused && row_focus >= current_topics_list.length) {
- row_focus = current_topics_list.length - 1;
- }
- topics_widget.remove_rendered_row($topic_row);
- } else if (!is_topic_rendered && filters_should_hide_row(topic_data)) {
- // In case `topic_row` is not present, our job is already done here
- // since it has not been rendered yet and we already removed it from
- // the filtered list in `topic_widget`. So, it won't be displayed in
- // the future too.
- } else if (is_topic_rendered && !filters_should_hide_row(topic_data)) {
+ if (filters_should_hide_row(topic_data)) {
+ // Nothing to do: the widget removed the row when the filtered list was
+ // recomputed, and a row never rendered stays out of the list.
+ } else if (is_topic_rendered) {
// Only a re-render is required in this case.
topics_widget.render_item(topic_data);
} else {
- // Final case: !is_topic_rendered && !filters_should_hide_row(topic_data).
topics_widget.insert_rendered_row(topic_data, () =>
current_topics_list.findIndex(
(list_item) => list_item.last_msg_id === topic_data.last_msg_id,
diff --git a/web/tests/list_widget.test.cjs b/web/tests/list_widget.test.cjs
index b2832cb7b20..f6470d83618 100644
--- a/web/tests/list_widget.test.cjs
+++ b/web/tests/list_widget.test.cjs
@@ -182,6 +182,54 @@ function div(item) {
return "<div>" + item + "</div>";
}
+function make_items(count) {
+ return Array.from({length: count}, (_, i) => ({value: i + 1, key: i + 1}));
+}
+
+// A widget over `list` with a stand-in for its DOM: `rows` holds the items
+// that have a row, in order, and refuses to render an item twice.
+function make_tracked_widget(list, opts = {}) {
+ const rows = [];
+ function items_in(html) {
+ return html
+ .matchAll(/data-item=(\d+)/g)
+ .map((match) => list[Number(match[1]) - 1])
+ .toArray();
+ }
+ function row(item) {
+ return {
+ get length() {
+ return rows.includes(item) ? 1 : 0;
+ },
+ remove() {
+ assert.ok(rows.includes(item), "row is not in the DOM");
+ rows.splice(rows.indexOf(item), 1);
+ },
+ };
+ }
+ const $container = make_container();
+ $container.append = ($data) => {
+ for (const item of items_in($data.html())) {
+ assert.ok(!rows.includes(item), `item ${item.value} was rendered twice`);
+ rows.push(item);
+ }
+ };
+ $container.empty = () => {
+ rows.length = 0;
+ };
+ const $scroll_container = make_scroll_container();
+ $scroll_container.find = ($row) => $row;
+ const widget = ListWidget.create($container, list, {
+ name: "tracked",
+ modifier_html: (item) => `<tr data-item=${item.value}></tr>\n`,
+ get_item: (item) => item,
+ html_selector: row,
+ $simplebar_container: $scroll_container,
+ ...opts,
+ });
+ return {widget, rows};
+}
+
run_test("scrolling", () => {
const $container = make_container();
const $scroll_container = make_scroll_container();
@@ -975,6 +1023,42 @@ run_test("render advances the offset by the rows appended", () => {
assert.ok(widget.all_rendered());
});
+run_test("filter_and_sort removes rows of items no longer listed", () => {
+ const list = make_items(100);
+ let hidden_items = new Set();
+ let render_count = 0;
+ const {widget, rows} = make_tracked_widget(list, {
+ filter: {predicate: (item) => !hidden_items.has(item)},
+ callback_after_render() {
+ render_count += 1;
+ },
+ });
+ assert.equal(render_count, 1);
+ assert.deepEqual(rows, list.slice(0, INITIAL_RENDER_COUNT));
+ assert.ok(!widget.all_rendered());
+
+ // Two rendered items and one not rendered yet get hidden without their
+ // rows being updated.
+ const hidden_rows = [rows[4], rows.at(-1)];
+ hidden_items = new Set([...hidden_rows, list.at(-1)]);
+ assert.deepEqual(widget.filter_and_sort(), hidden_rows);
+ assert.equal(rows.length, INITIAL_RENDER_COUNT - hidden_rows.length);
+ // The rendered list still matches the rows in the DOM, so rendering
+ // more continues right after them, duplicating nothing.
+ assert.deepEqual(widget.get_rendered_list(), rows);
+ widget.render();
+ assert.equal(render_count, 2);
+ assert.equal(rows.length, list.length - hidden_items.size);
+ assert.deepEqual(widget.get_rendered_list(), rows);
+ assert.ok(widget.all_rendered());
+
+ // With everything rendered, removing rows calls render() once, so that
+ // an emptied list shows its empty-list message.
+ hidden_items.add(list[0]);
+ assert.deepEqual(widget.filter_and_sort(), [list[0]]);
+ assert.equal(render_count, 3);
+});
+
run_test("Multiselect dropdown retain_selected_items", () => {
const $container = make_container();
const $scroll_container = make_scroll_container();
diff --git a/web/tests/recent_view.test.cjs b/web/tests/recent_view.test.cjs
index 427e6ec7725..84e8c09d709 100644
--- a/web/tests/recent_view.test.cjs
+++ b/web/tests/recent_view.test.cjs
@@ -82,7 +82,7 @@ const ListWidget = mock_esm("../src/list_widget", {
},
hard_redraw: noop,
- filter_and_sort: noop,
+ filter_and_sort: () => [],
replace_list_data(data) {
assert.notEqual(
expected_data_to_replace_in_list_widget,
@@ -181,6 +181,7 @@ mock_esm("../src/unread", {
}
return 1;
},
+ get_unread_message_count: () => 0,
num_unread_for_user_ids_string() {
return 0;
},