actioncable 6.1.3.1 → 7.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e0e852bb8fa5267eff346a9aef794e6de1a2e9d0e62957453e6afdcfcea48d9
-  data.tar.gz: 406480de8ebdfe0532819a4a5a17bc93d896849c8ab0a47ea06077c69c3799fb
+  metadata.gz: ae20b4c4ec6fe995164eb0a9701a3f79c92b8859e71aa10d1a95e2fd243a25ad
+  data.tar.gz: 69426337d819a6f40f24a4b57b5b0bd75bb0cdd8066da0eff4c8967c68a7a240
 SHA512:
-  metadata.gz: e76c5c926ec4c818018968ba2b7d6f9464a020c1306efe66e18565f599233230f3a4766587c4274744d6e123c5f031c82b1000e820d762467b7522cc11ef6201
-  data.tar.gz: c0bb3bf3b2327a68c493d4f7b4369878770439c4bfdfd85499b7caa86dcafc480021ee44e96c82caf96c62ecfebec1b052ec4f88707bad30eeb1487be88b74e4
+  metadata.gz: b5f2b7b8028ef108170d53c6287fc652ecdf24e5c0d91bac0075003a56972462369fd0b2a4bcd071b1ee1b8800c4bede4b2b8d12e55f421915304ea8475002ad
+  data.tar.gz: 42a713b80aeafdb15c951f691d2a2f29fcbbcc3eb350439cc4d10614b534d6a959315cf990a681458267f06b8f12da8cd211035a0041fcb16b65cc55c0e1e88c

data/CHANGELOG.md

@@ -1,65 +1,37 @@
-## Rails 6.1.3.1 (March 26, 2021) ##
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-*   No changes.
+*   Compile ESM package that can be used directly in the browser as actioncable.esm.js.
 
+    *DHH*
 
-## Rails 6.1.3 (February 17, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.2.1 (February 10, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.2 (February 09, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.1 (January 07, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.0 (December 09, 2020) ##
-
-*   `ActionCable::Connection::Base` now allows intercepting unhandled exceptions
-    with `rescue_from` before they are logged, which is useful for error reporting
-    tools and other integrations.
-
-    *Justin Talbott*
+*   Move action_cable.js to actioncable.js to match naming convention used for other Rails frameworks, and use JS console to communicate the deprecation.
 
-*   Add `ActionCable::Channel#stream_or_reject_for` to stream if record is present, otherwise reject the connection
+    *DHH*
 
-    *Atul Bhosale*
+*   Stop transpiling the UMD package generated as actioncable.js and drop the IE11 testing that relied on that.
 
-*   Add `ActionCable::Channel#stop_stream_from` and `#stop_stream_for` to unsubscribe from a specific stream.
+    *DHH*
 
-    *Zhang Kang*
+*   Truncate broadcast logging messages.
 
-*   Add PostgreSQL subscription connection identificator.
+    *J Smith*
 
-    Now you can distinguish Action Cable PostgreSQL subscription connections among others.
-    Also, you can set custom `id` in `cable.yml` configuration.
+*   OpenSSL constants are now used for Digest computations.
 
-    ```sql
-    SELECT application_name FROM pg_stat_activity;
-    /*
-        application_name
-    ------------------------
-    psql
-    ActionCable-PID-42
-    (2 rows)
-    */
-    ```
+    *Dirkjan Bussink*
 
-    *Sergey Ponomarev*
+*   The Action Cable client now includes safeguards to prevent a "thundering
+    herd" of client reconnects after server connectivity loss:
 
-*   Subscription confirmations and rejections are now logged at the `DEBUG` level instead of `INFO`.
+    * The client will wait a random amount between 1x and 3x of the stale
+      threshold after the server's last ping before making the first
+      reconnection attempt.
+    * Subsequent reconnection attempts now use exponential backoff instead of
+      logarithmic backoff.  To allow the delay between reconnection attempts to
+      increase slowly at first, the default exponentiation base is < 2.
+    * Random jitter is applied to each delay between reconnection attempts.
 
-    *DHH*
+    *Jonathan Hefner*
 
 
-Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/actioncable/CHANGELOG.md) for previous changes.
+Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/actioncable/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2015-2020 Basecamp, LLC
+Copyright (c) 2015-2021 Basecamp, LLC
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/app/assets/javascripts/action_cable.js

@@ -1,154 +1,115 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : factory(global.ActionCable = {});
-})(this, function(exports) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define([ "exports" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+  factory(global.ActionCable = {}));
+})(this, (function(exports) {
   "use strict";
   var adapters = {
     logger: self.console,
     WebSocket: self.WebSocket
   };
   var logger = {
-    log: function log() {
+    log(...messages) {
       if (this.enabled) {
-        var _adapters$logger;
-        for (var _len = arguments.length, messages = Array(_len), _key = 0; _key < _len; _key++) {
-          messages[_key] = arguments[_key];
-        }
         messages.push(Date.now());
-        (_adapters$logger = adapters.logger).log.apply(_adapters$logger, [ "[ActionCable]" ].concat(messages));
-      }
-    }
-  };
-  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
-    return typeof obj;
-  } : function(obj) {
-    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  };
-  var classCallCheck = function(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  };
-  var createClass = function() {
-    function defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
+        adapters.logger.log("[ActionCable]", ...messages);
       }
     }
-    return function(Constructor, protoProps, staticProps) {
-      if (protoProps) defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) defineProperties(Constructor, staticProps);
-      return Constructor;
-    };
-  }();
-  var now = function now() {
-    return new Date().getTime();
-  };
-  var secondsSince = function secondsSince(time) {
-    return (now() - time) / 1e3;
   };
-  var clamp = function clamp(number, min, max) {
-    return Math.max(min, Math.min(max, number));
-  };
-  var ConnectionMonitor = function() {
-    function ConnectionMonitor(connection) {
-      classCallCheck(this, ConnectionMonitor);
+  const now = () => (new Date).getTime();
+  const secondsSince = time => (now() - time) / 1e3;
+  class ConnectionMonitor {
+    constructor(connection) {
       this.visibilityDidChange = this.visibilityDidChange.bind(this);
       this.connection = connection;
       this.reconnectAttempts = 0;
     }
-    ConnectionMonitor.prototype.start = function start() {
+    start() {
       if (!this.isRunning()) {
         this.startedAt = now();
         delete this.stoppedAt;
         this.startPolling();
         addEventListener("visibilitychange", this.visibilityDidChange);
-        logger.log("ConnectionMonitor started. pollInterval = " + this.getPollInterval() + " ms");
+        logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
       }
-    };
-    ConnectionMonitor.prototype.stop = function stop() {
+    }
+    stop() {
       if (this.isRunning()) {
         this.stoppedAt = now();
         this.stopPolling();
         removeEventListener("visibilitychange", this.visibilityDidChange);
         logger.log("ConnectionMonitor stopped");
       }
-    };
-    ConnectionMonitor.prototype.isRunning = function isRunning() {
+    }
+    isRunning() {
       return this.startedAt && !this.stoppedAt;
-    };
-    ConnectionMonitor.prototype.recordPing = function recordPing() {
+    }
+    recordPing() {
       this.pingedAt = now();
-    };
-    ConnectionMonitor.prototype.recordConnect = function recordConnect() {
+    }
+    recordConnect() {
       this.reconnectAttempts = 0;
       this.recordPing();
       delete this.disconnectedAt;
       logger.log("ConnectionMonitor recorded connect");
-    };
-    ConnectionMonitor.prototype.recordDisconnect = function recordDisconnect() {
+    }
+    recordDisconnect() {
       this.disconnectedAt = now();
       logger.log("ConnectionMonitor recorded disconnect");
-    };
-    ConnectionMonitor.prototype.startPolling = function startPolling() {
+    }
+    startPolling() {
       this.stopPolling();
       this.poll();
-    };
-    ConnectionMonitor.prototype.stopPolling = function stopPolling() {
+    }
+    stopPolling() {
       clearTimeout(this.pollTimeout);
-    };
-    ConnectionMonitor.prototype.poll = function poll() {
-      var _this = this;
-      this.pollTimeout = setTimeout(function() {
-        _this.reconnectIfStale();
-        _this.poll();
-      }, this.getPollInterval());
-    };
-    ConnectionMonitor.prototype.getPollInterval = function getPollInterval() {
-      var _constructor$pollInte = this.constructor.pollInterval, min = _constructor$pollInte.min, max = _constructor$pollInte.max, multiplier = _constructor$pollInte.multiplier;
-      var interval = multiplier * Math.log(this.reconnectAttempts + 1);
-      return Math.round(clamp(interval, min, max) * 1e3);
-    };
-    ConnectionMonitor.prototype.reconnectIfStale = function reconnectIfStale() {
+    }
+    poll() {
+      this.pollTimeout = setTimeout((() => {
+        this.reconnectIfStale();
+        this.poll();
+      }), this.getPollInterval());
+    }
+    getPollInterval() {
+      const {staleThreshold: staleThreshold, reconnectionBackoffRate: reconnectionBackoffRate} = this.constructor;
+      const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
+      const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
+      const jitter = jitterMax * Math.random();
+      return staleThreshold * 1e3 * backoff * (1 + jitter);
+    }
+    reconnectIfStale() {
       if (this.connectionIsStale()) {
-        logger.log("ConnectionMonitor detected stale connection. reconnectAttempts = " + this.reconnectAttempts + ", pollInterval = " + this.getPollInterval() + " ms, time disconnected = " + secondsSince(this.disconnectedAt) + " s, stale threshold = " + this.constructor.staleThreshold + " s");
+        logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
         this.reconnectAttempts++;
         if (this.disconnectedRecently()) {
-          logger.log("ConnectionMonitor skipping reopening recent disconnect");
+          logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
         } else {
           logger.log("ConnectionMonitor reopening");
           this.connection.reopen();
         }
       }
-    };
-    ConnectionMonitor.prototype.connectionIsStale = function connectionIsStale() {
-      return secondsSince(this.pingedAt ? this.pingedAt : this.startedAt) > this.constructor.staleThreshold;
-    };
-    ConnectionMonitor.prototype.disconnectedRecently = function disconnectedRecently() {
+    }
+    get refreshedAt() {
+      return this.pingedAt ? this.pingedAt : this.startedAt;
+    }
+    connectionIsStale() {
+      return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
+    }
+    disconnectedRecently() {
       return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
-    };
-    ConnectionMonitor.prototype.visibilityDidChange = function visibilityDidChange() {
-      var _this2 = this;
+    }
+    visibilityDidChange() {
       if (document.visibilityState === "visible") {
-        setTimeout(function() {
-          if (_this2.connectionIsStale() || !_this2.connection.isOpen()) {
-            logger.log("ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = " + document.visibilityState);
-            _this2.connection.reopen();
+        setTimeout((() => {
+          if (this.connectionIsStale() || !this.connection.isOpen()) {
+            logger.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
+            this.connection.reopen();
           }
-        }, 200);
+        }), 200);
       }
-    };
-    return ConnectionMonitor;
-  }();
-  ConnectionMonitor.pollInterval = {
-    min: 3,
-    max: 30,
-    multiplier: 5
-  };
+    }
+  }
   ConnectionMonitor.staleThreshold = 6;
+  ConnectionMonitor.reconnectionBackoffRate = .15;
   var INTERNAL = {
     message_types: {
       welcome: "welcome",
@@ -165,32 +126,31 @@
     default_mount_path: "/cable",
     protocols: [ "actioncable-v1-json", "actioncable-unsupported" ]
   };
-  var message_types = INTERNAL.message_types, protocols = INTERNAL.protocols;
-  var supportedProtocols = protocols.slice(0, protocols.length - 1);
-  var indexOf = [].indexOf;
-  var Connection = function() {
-    function Connection(consumer) {
-      classCallCheck(this, Connection);
+  const {message_types: message_types, protocols: protocols} = INTERNAL;
+  const supportedProtocols = protocols.slice(0, protocols.length - 1);
+  const indexOf = [].indexOf;
+  class Connection {
+    constructor(consumer) {
       this.open = this.open.bind(this);
       this.consumer = consumer;
       this.subscriptions = this.consumer.subscriptions;
       this.monitor = new ConnectionMonitor(this);
       this.disconnected = true;
     }
-    Connection.prototype.send = function send(data) {
+    send(data) {
       if (this.isOpen()) {
         this.webSocket.send(JSON.stringify(data));
         return true;
       } else {
         return false;
       }
-    };
-    Connection.prototype.open = function open() {
+    }
+    open() {
       if (this.isActive()) {
-        logger.log("Attempted to open WebSocket, but existing socket is " + this.getState());
+        logger.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
         return false;
       } else {
-        logger.log("Opening WebSocket, current state is " + this.getState() + ", subprotocols: " + protocols);
+        logger.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${protocols}`);
         if (this.webSocket) {
           this.uninstallEventHandlers();
         }
@@ -199,90 +159,85 @@
         this.monitor.start();
         return true;
       }
-    };
-    Connection.prototype.close = function close() {
-      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-        allowReconnect: true
-      }, allowReconnect = _ref.allowReconnect;
+    }
+    close({allowReconnect: allowReconnect} = {
+      allowReconnect: true
+    }) {
       if (!allowReconnect) {
         this.monitor.stop();
       }
       if (this.isActive()) {
         return this.webSocket.close();
       }
-    };
-    Connection.prototype.reopen = function reopen() {
-      logger.log("Reopening WebSocket, current state is " + this.getState());
+    }
+    reopen() {
+      logger.log(`Reopening WebSocket, current state is ${this.getState()}`);
       if (this.isActive()) {
         try {
           return this.close();
         } catch (error) {
           logger.log("Failed to reopen WebSocket", error);
         } finally {
-          logger.log("Reopening WebSocket in " + this.constructor.reopenDelay + "ms");
+          logger.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
           setTimeout(this.open, this.constructor.reopenDelay);
         }
       } else {
         return this.open();
       }
-    };
-    Connection.prototype.getProtocol = function getProtocol() {
+    }
+    getProtocol() {
       if (this.webSocket) {
         return this.webSocket.protocol;
       }
-    };
-    Connection.prototype.isOpen = function isOpen() {
+    }
+    isOpen() {
       return this.isState("open");
-    };
-    Connection.prototype.isActive = function isActive() {
+    }
+    isActive() {
       return this.isState("open", "connecting");
-    };
-    Connection.prototype.isProtocolSupported = function isProtocolSupported() {
+    }
+    isProtocolSupported() {
       return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
-    };
-    Connection.prototype.isState = function isState() {
-      for (var _len = arguments.length, states = Array(_len), _key = 0; _key < _len; _key++) {
-        states[_key] = arguments[_key];
-      }
+    }
+    isState(...states) {
       return indexOf.call(states, this.getState()) >= 0;
-    };
-    Connection.prototype.getState = function getState() {
+    }
+    getState() {
       if (this.webSocket) {
-        for (var state in adapters.WebSocket) {
+        for (let state in adapters.WebSocket) {
           if (adapters.WebSocket[state] === this.webSocket.readyState) {
             return state.toLowerCase();
           }
         }
       }
       return null;
-    };
-    Connection.prototype.installEventHandlers = function installEventHandlers() {
-      for (var eventName in this.events) {
-        var handler = this.events[eventName].bind(this);
-        this.webSocket["on" + eventName] = handler;
+    }
+    installEventHandlers() {
+      for (let eventName in this.events) {
+        const handler = this.events[eventName].bind(this);
+        this.webSocket[`on${eventName}`] = handler;
       }
-    };
-    Connection.prototype.uninstallEventHandlers = function uninstallEventHandlers() {
-      for (var eventName in this.events) {
-        this.webSocket["on" + eventName] = function() {};
+    }
+    uninstallEventHandlers() {
+      for (let eventName in this.events) {
+        this.webSocket[`on${eventName}`] = function() {};
       }
-    };
-    return Connection;
-  }();
+    }
+  }
   Connection.reopenDelay = 500;
   Connection.prototype.events = {
-    message: function message(event) {
+    message(event) {
       if (!this.isProtocolSupported()) {
         return;
       }
-      var _JSON$parse = JSON.parse(event.data), identifier = _JSON$parse.identifier, message = _JSON$parse.message, reason = _JSON$parse.reason, reconnect = _JSON$parse.reconnect, type = _JSON$parse.type;
+      const {identifier: identifier, message: message, reason: reason, reconnect: reconnect, type: type} = JSON.parse(event.data);
       switch (type) {
        case message_types.welcome:
         this.monitor.recordConnect();
         return this.subscriptions.reload();
 
        case message_types.disconnect:
-        logger.log("Disconnecting. Reason: " + reason);
+        logger.log(`Disconnecting. Reason: ${reason}`);
         return this.close({
           allowReconnect: reconnect
         });
@@ -300,8 +255,8 @@
         return this.subscriptions.notify(identifier, "received", message);
       }
     },
-    open: function open() {
-      logger.log("WebSocket onopen event, using '" + this.getProtocol() + "' subprotocol");
+    open() {
+      logger.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
       this.disconnected = false;
       if (!this.isProtocolSupported()) {
         logger.log("Protocol is unsupported. Stopping monitor and disconnecting.");
@@ -310,7 +265,7 @@
         });
       }
     },
-    close: function close(event) {
+    close(event) {
       logger.log("WebSocket onclose event");
       if (this.disconnected) {
         return;
@@ -321,167 +276,136 @@
         willAttemptReconnect: this.monitor.isRunning()
       });
     },
-    error: function error() {
+    error() {
       logger.log("WebSocket onerror event");
     }
   };
-  var extend = function extend(object, properties) {
+  const extend = function(object, properties) {
     if (properties != null) {
-      for (var key in properties) {
-        var value = properties[key];
+      for (let key in properties) {
+        const value = properties[key];
         object[key] = value;
       }
     }
     return object;
   };
-  var Subscription = function() {
-    function Subscription(consumer) {
-      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var mixin = arguments[2];
-      classCallCheck(this, Subscription);
+  class Subscription {
+    constructor(consumer, params = {}, mixin) {
       this.consumer = consumer;
       this.identifier = JSON.stringify(params);
       extend(this, mixin);
     }
-    Subscription.prototype.perform = function perform(action) {
-      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    perform(action, data = {}) {
       data.action = action;
       return this.send(data);
-    };
-    Subscription.prototype.send = function send(data) {
+    }
+    send(data) {
       return this.consumer.send({
         command: "message",
         identifier: this.identifier,
         data: JSON.stringify(data)
       });
-    };
-    Subscription.prototype.unsubscribe = function unsubscribe() {
+    }
+    unsubscribe() {
       return this.consumer.subscriptions.remove(this);
-    };
-    return Subscription;
-  }();
-  var Subscriptions = function() {
-    function Subscriptions(consumer) {
-      classCallCheck(this, Subscriptions);
+    }
+  }
+  class Subscriptions {
+    constructor(consumer) {
       this.consumer = consumer;
       this.subscriptions = [];
     }
-    Subscriptions.prototype.create = function create(channelName, mixin) {
-      var channel = channelName;
-      var params = (typeof channel === "undefined" ? "undefined" : _typeof(channel)) === "object" ? channel : {
+    create(channelName, mixin) {
+      const channel = channelName;
+      const params = typeof channel === "object" ? channel : {
         channel: channel
       };
-      var subscription = new Subscription(this.consumer, params, mixin);
+      const subscription = new Subscription(this.consumer, params, mixin);
       return this.add(subscription);
-    };
-    Subscriptions.prototype.add = function add(subscription) {
+    }
+    add(subscription) {
       this.subscriptions.push(subscription);
       this.consumer.ensureActiveConnection();
       this.notify(subscription, "initialized");
       this.sendCommand(subscription, "subscribe");
       return subscription;
-    };
-    Subscriptions.prototype.remove = function remove(subscription) {
+    }
+    remove(subscription) {
       this.forget(subscription);
       if (!this.findAll(subscription.identifier).length) {
         this.sendCommand(subscription, "unsubscribe");
       }
       return subscription;
-    };
-    Subscriptions.prototype.reject = function reject(identifier) {
-      var _this = this;
-      return this.findAll(identifier).map(function(subscription) {
-        _this.forget(subscription);
-        _this.notify(subscription, "rejected");
+    }
+    reject(identifier) {
+      return this.findAll(identifier).map((subscription => {
+        this.forget(subscription);
+        this.notify(subscription, "rejected");
         return subscription;
-      });
-    };
-    Subscriptions.prototype.forget = function forget(subscription) {
-      this.subscriptions = this.subscriptions.filter(function(s) {
-        return s !== subscription;
-      });
+      }));
+    }
+    forget(subscription) {
+      this.subscriptions = this.subscriptions.filter((s => s !== subscription));
       return subscription;
-    };
-    Subscriptions.prototype.findAll = function findAll(identifier) {
-      return this.subscriptions.filter(function(s) {
-        return s.identifier === identifier;
-      });
-    };
-    Subscriptions.prototype.reload = function reload() {
-      var _this2 = this;
-      return this.subscriptions.map(function(subscription) {
-        return _this2.sendCommand(subscription, "subscribe");
-      });
-    };
-    Subscriptions.prototype.notifyAll = function notifyAll(callbackName) {
-      var _this3 = this;
-      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
-      }
-      return this.subscriptions.map(function(subscription) {
-        return _this3.notify.apply(_this3, [ subscription, callbackName ].concat(args));
-      });
-    };
-    Subscriptions.prototype.notify = function notify(subscription, callbackName) {
-      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-        args[_key2 - 2] = arguments[_key2];
-      }
-      var subscriptions = void 0;
+    }
+    findAll(identifier) {
+      return this.subscriptions.filter((s => s.identifier === identifier));
+    }
+    reload() {
+      return this.subscriptions.map((subscription => this.sendCommand(subscription, "subscribe")));
+    }
+    notifyAll(callbackName, ...args) {
+      return this.subscriptions.map((subscription => this.notify(subscription, callbackName, ...args)));
+    }
+    notify(subscription, callbackName, ...args) {
+      let subscriptions;
       if (typeof subscription === "string") {
         subscriptions = this.findAll(subscription);
       } else {
         subscriptions = [ subscription ];
       }
-      return subscriptions.map(function(subscription) {
-        return typeof subscription[callbackName] === "function" ? subscription[callbackName].apply(subscription, args) : undefined;
-      });
-    };
-    Subscriptions.prototype.sendCommand = function sendCommand(subscription, command) {
-      var identifier = subscription.identifier;
+      return subscriptions.map((subscription => typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined));
+    }
+    sendCommand(subscription, command) {
+      const {identifier: identifier} = subscription;
       return this.consumer.send({
         command: command,
         identifier: identifier
       });
-    };
-    return Subscriptions;
-  }();
-  var Consumer = function() {
-    function Consumer(url) {
-      classCallCheck(this, Consumer);
+    }
+  }
+  class Consumer {
+    constructor(url) {
       this._url = url;
       this.subscriptions = new Subscriptions(this);
       this.connection = new Connection(this);
     }
-    Consumer.prototype.send = function send(data) {
+    get url() {
+      return createWebSocketURL(this._url);
+    }
+    send(data) {
       return this.connection.send(data);
-    };
-    Consumer.prototype.connect = function connect() {
+    }
+    connect() {
       return this.connection.open();
-    };
-    Consumer.prototype.disconnect = function disconnect() {
+    }
+    disconnect() {
       return this.connection.close({
         allowReconnect: false
       });
-    };
-    Consumer.prototype.ensureActiveConnection = function ensureActiveConnection() {
+    }
+    ensureActiveConnection() {
       if (!this.connection.isActive()) {
         return this.connection.open();
       }
-    };
-    createClass(Consumer, [ {
-      key: "url",
-      get: function get$$1() {
-        return createWebSocketURL(this._url);
-      }
-    } ]);
-    return Consumer;
-  }();
+    }
+  }
   function createWebSocketURL(url) {
     if (typeof url === "function") {
       url = url();
     }
     if (url && !/^wss?:/i.test(url)) {
-      var a = document.createElement("a");
+      const a = document.createElement("a");
       a.href = url;
       a.href = a.href;
       a.protocol = a.protocol.replace("http", "ws");
@@ -490,16 +414,16 @@
       return url;
     }
   }
-  function createConsumer() {
-    var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getConfig("url") || INTERNAL.default_mount_path;
+  function createConsumer(url = getConfig("url") || INTERNAL.default_mount_path) {
     return new Consumer(url);
   }
   function getConfig(name) {
-    var element = document.head.querySelector("meta[name='action-cable-" + name + "']");
+    const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
     if (element) {
       return element.getAttribute("content");
     }
   }
+  console.log("DEPRECATION: action_cable.js has been renamed to actioncable.js – please update your reference before Rails 8");
   exports.Connection = Connection;
   exports.ConnectionMonitor = ConnectionMonitor;
   exports.Consumer = Consumer;
@@ -507,11 +431,11 @@
   exports.Subscription = Subscription;
   exports.Subscriptions = Subscriptions;
   exports.adapters = adapters;
-  exports.createWebSocketURL = createWebSocketURL;
-  exports.logger = logger;
   exports.createConsumer = createConsumer;
+  exports.createWebSocketURL = createWebSocketURL;
   exports.getConfig = getConfig;
+  exports.logger = logger;
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
-});
+}));