zulip/static/js/typing.js

80 lines
2.1 KiB
JavaScript
Raw Normal View History

"use strict";
const typing_status = require("../shared/js/typing_status");
2020-08-20 21:24:06 +02:00
const people = require("./people");
2017-03-22 15:11:41 +01:00
// This module handles the outbound side of typing indicators.
// We detect changes in the compose box and notify the server
// when we are typing. For the inbound side see typing_events.js.
2017-09-25 20:33:29 +02:00
//
// See docs/subsystems/typing-indicators.md for details on typing indicators.
function send_typing_notification_ajax(user_ids_array, operation) {
channel.post({
url: "/json/typing",
data: {
to: JSON.stringify(user_ids_array),
op: operation,
},
success() {},
error(xhr) {
blueslip.warn("Failed to send typing event: " + xhr.responseText);
},
});
}
function get_user_ids_array() {
const user_ids_string = compose_pm_pill.get_user_ids_string();
if (user_ids_string === "") {
return null;
}
return people.user_ids_string_to_ids_array(user_ids_string);
}
typing_status: Combine two parameters into one, with a maybe-type. The main motivation for this change is to simplify this interface and make it easier to reason about. The case where it affects the behavior is when is_valid_conversation() returns false, while current_recipient and get_recipient() agree on some truthy value. This means the message-content textarea is empty -- in fact the user just cleared it, because we got here from an input event on it -- but the compose box is still open to some PM thread that we have a typing notification still outstanding for. The old behavior is that in this situation we would ignore the fact that the content was empty, and go ahead and prolong the typing notification, by updating our timer and possibly sending a "still typing" notice. This contrasts with the behavior (both old and new) in the case where the content is empty and we *don't* already have an outstanding typing notification, or we have one to some other thread. In that case, we cancel any existing notification and don't start a new one, exactly as if `stop` were called (e.g. because the user closed the compose box.) The new behavior is that we always treat clearing the input as "stopped typing": not only in those cases where we already did, but also in the case where we still have the same recipients. (Which seems like probably the common case.) That seems like the preferable behavior; indeed it's hard to see the point of the "compose_empty" logic if restricted to the other cases. It also makes the interface simpler. Those two properties don't seem like a coincidence, either: the complicated interface made it difficult to unpack exactly what logic we actually had, which made it easy for surprising wrinkles to hang out indefinitely.
2019-10-21 23:37:22 +02:00
function is_valid_conversation() {
const compose_empty = !compose_state.has_message_content();
if (compose_empty) {
return false;
}
return true;
}
function get_current_time() {
return new Date().getTime();
}
function notify_server_start(user_ids_array) {
send_typing_notification_ajax(user_ids_array, "start");
}
function notify_server_stop(user_ids_array) {
send_typing_notification_ajax(user_ids_array, "stop");
}
exports.get_recipient = get_user_ids_array;
exports.initialize = function () {
const worker = {
get_current_time,
notify_server_start,
notify_server_stop,
};
$(document).on("input", "#compose-textarea", () => {
// If our previous state was no typing notification, send a
// start-typing notice immediately.
const new_recipient = is_valid_conversation() ? exports.get_recipient() : null;
typing_status.update(worker, new_recipient);
});
// We send a stop-typing notification immediately when compose is
// closed/cancelled
$(document).on("compose_canceled.zulip compose_finished.zulip", () => {
typing_status.update(worker, null);
});
};
window.typing = exports;