Convert "reliable trigger" to TypeScript

ts/backbone/backboneJquery.ts

@@ -0,0 +1,6 @@
+// Copyright 2020-2022 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+// we are requiring backbone in preload.js, and we need to tell backbone where
+// jquery is after it's loaded.
+window.Backbone.$ = window.Backbone.$ || window.$;

ts/backbone/reliable_trigger.ts

@@ -0,0 +1,157 @@
+// Copyright 2017-2022 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import type * as Backbone from 'backbone';
+
+type InternalBackboneEvent = {
+  callback: (...args: Array<unknown>) => unknown;
+  ctx: unknown;
+};
+
+/* eslint-disable */
+
+// This file was taken from Backbone and then modified. It does not conform to this
+//   project's standards.
+
+// Note: this is all the code required to customize Backbone's trigger() method to make
+//   it resilient to exceptions thrown by event handlers. Indentation and code styles
+//   were kept inline with the Backbone implementation for easier diffs.
+
+// The changes are:
+//   1. added 'name' parameter to triggerEvents to give it access to the
+//      current event name
+//   2. added try/catch handlers to triggerEvents with error logging inside
+//      every while loop
+
+// And of course, we update the protoypes of Backbone.Model/Backbone.View as well as
+//   Backbone.Events itself
+
+// Regular expression used to split event strings.
+const eventSplitter = /\s+/;
+
+// Implement fancy features of the Events API such as multiple event
+// names `"change blur"` and jQuery-style event maps `{change: action}`
+// in terms of the existing API.
+const eventsApi = function (
+  obj: Backbone.Events,
+  name: string | Record<string, unknown>,
+  rest: ReadonlyArray<unknown>
+) {
+  if (!name) return true;
+
+  // Handle event maps.
+  if (typeof name === 'object') {
+    for (const key in name) {
+      obj.trigger(key, name[key], ...rest);
+    }
+    return false;
+  }
+
+  // Handle space separated event names.
+  if (eventSplitter.test(name)) {
+    const names = name.split(eventSplitter);
+    for (let i = 0, l = names.length; i < l; i++) {
+      obj.trigger(names[i], ...rest);
+    }
+    return false;
+  }
+
+  return true;
+};
+
+// A difficult-to-believe, but optimized internal dispatch function for
+// triggering events. Tries to keep the usual cases speedy (most internal
+// Backbone events have 3 arguments).
+const triggerEvents = function (
+  events: ReadonlyArray<InternalBackboneEvent>,
+  name: string,
+  args: Array<unknown>
+) {
+  let ev,
+    i = -1,
+    l = events.length,
+    a1 = args[0],
+    a2 = args[1],
+    a3 = args[2];
+  const logError = function (error: unknown) {
+    window.SignalContext.log.error(
+      'Model caught error triggering',
+      name,
+      'event:',
+      error && error instanceof Error && error.stack ? error.stack : error
+    );
+  };
+  switch (args.length) {
+    case 0:
+      while (++i < l) {
+        try {
+          (ev = events[i]).callback.call(ev.ctx);
+        } catch (error) {
+          logError(error);
+        }
+      }
+      return;
+    case 1:
+      while (++i < l) {
+        try {
+          (ev = events[i]).callback.call(ev.ctx, a1);
+        } catch (error) {
+          logError(error);
+        }
+      }
+      return;
+    case 2:
+      while (++i < l) {
+        try {
+          (ev = events[i]).callback.call(ev.ctx, a1, a2);
+        } catch (error) {
+          logError(error);
+        }
+      }
+      return;
+    case 3:
+      while (++i < l) {
+        try {
+          (ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
+        } catch (error) {
+          logError(error);
+        }
+      }
+      return;
+    default:
+      while (++i < l) {
+        try {
+          (ev = events[i]).callback.apply(ev.ctx, args);
+        } catch (error) {
+          logError(error);
+        }
+      }
+  }
+};
+
+// Trigger one or many events, firing all bound callbacks. Callbacks are
+// passed the same arguments as `trigger` is, apart from the event name
+// (unless you're listening on `"all"`, which will cause your callback to
+// receive the true name of the event as the first argument).
+function trigger<
+  T extends Backbone.Events & {
+    _events: undefined | Record<string, ReadonlyArray<InternalBackboneEvent>>;
+  }
+>(this: T, name: string, ...args: Array<unknown>): T {
+  if (!this._events) return this;
+  if (!eventsApi(this, name, args)) return this;
+  const events = this._events[name];
+  const allEvents = this._events.all;
+  if (events) triggerEvents(events, name, args);
+  if (allEvents) triggerEvents(allEvents, name, [...arguments]);
+  return this;
+}
+
+[
+  window.Backbone.Model.prototype,
+  window.Backbone.View.prototype,
+  window.Backbone.Collection.prototype,
+  window.Backbone.Events,
+].forEach(proto => {
+  Object.assign(proto, { trigger });
+});