MDL-72609 behat: Rewrite core/pending to observe ES6 style

This commit makes the following changes:
* convert to use ES6 module format
* migrate from a jQuery Deferred to a native ES6 promise
* add a native-Promise-like instantiation

New uses are documented in appropriate jsdoc with examples.

lib/amd/build/pending.min.js

@@ -1,11 +1,12 @@
+define("core/pending",["exports"],(function(_exports){Object.defineProperty(_exports,"__esModule",{value:!0}),_exports.default=void 0;return _exports.default=
 /**
- * A helper to manage pendingJS checks.
- *
- * @module     core/pending
- * @copyright  2018 Andrew Nicols <andrew@nicols.co.uk>
- * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
- * @since      3.6
- */
-define("core/pending",["jquery"],(function($){var request=function(pendingKey){var pendingPromise=$.Deferred();return pendingKey=pendingKey||{},M.util.js_pending(pendingKey),pendingPromise.then((function(){return M.util.js_complete(pendingKey)})).catch(),pendingPromise};return request.prototype.constructor=request,request}));
+   * A helper used to inform Behat that an operation is in progress and that Behat must wait for it to complete.
+   *
+   * @module     core/pending
+   * @copyright  2018 Andrew Nicols <andrew@nicols.co.uk>
+   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
+   * @since      3.6
+   */
+class{static request(pendingKey){return window.console.error("The core/pending::request method has been deprecated. "+"Please use one of the alternative calls to core/pending, for example \"new Pending('".concat(pendingKey,"')\". ")+"Called with ".concat(pendingKey)),new this(pendingKey)}constructor(){let resolver,rejector,pendingKey=arguments.length>0&&void 0!==arguments[0]?arguments[0]:"pendingPromise";const pendingPromise=this.constructor.Promise(((resolve,reject)=>{resolver=resolve,rejector=reject}),pendingKey);return pendingPromise.resolve=resolver,pendingPromise.reject=rejector,pendingPromise}static Promise(fn){let pendingKey=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"pendingPromise";const resolver=new Promise(((resolve,reject)=>{M.util.js_pending(pendingKey),fn(resolve,reject)}));return resolver.then((()=>{M.util.js_complete(pendingKey)})).catch(),resolver}},_exports.default}));
 
 //# sourceMappingURL=pending.min.js.map

lib/amd/src/pending.js

@@ -14,38 +14,112 @@
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
 /**
- * A helper to manage pendingJS checks.
+ * A helper used to inform Behat that an operation is in progress and that Behat must wait for it to complete.
  *
  * @module     core/pending
  * @copyright  2018 Andrew Nicols <andrew@nicols.co.uk>
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  * @since      3.6
  */
-define(['jquery'], function($) {
 
-   /**
-    * Request a new pendingPromise to be resolved.
-    *
-    * When the action you are performing is complete, simply call resolve on the returned Promise.
-    *
-    * @param    {Object}    pendingKey An optional key value to use
-    * @return   {Promise}
-    */
-    var request = function(pendingKey) {
-        var pendingPromise = $.Deferred();
+/**
+ * A helper used to register any long-running operations that are in-progress and that Behat must wait for it to complete.
+ *
+ * This is useful in cases where the user interface may be updated and take some time to change - for example where
+ * applying a transition.
+ *
+ * This data is used by Behat, but may also be consumed by other location too.
+ *
+ * By informing Behat that an action is about to happen, and then that it is complete, allows
+ * Behat to wait for that completion and avoid random failures in automated testing.
+ *
+ * Note: It is recommended that a descriptive key be used to aid in debugging where possible, but this is optional.
+ */
+export default class {
 
-        pendingKey = pendingKey || {};
-        M.util.js_pending(pendingKey);
+    /**
+     * Create a new Pending Promise statically.
+     *
+     * @param {String} pendingKey An identifier to help in debugging
+     * @return {Promise} A Native Promise
+     * @deprecated since Moodle 4.2
+     */
+    static request(pendingKey) {
+        window.console.error(
+            `The core/pending::request method has been deprecated. ` +
+            `Please use one of the alternative calls to core/pending, for example "new Pending('${pendingKey}')". ` +
+            `Called with ${pendingKey}`
+        );
+        return new this(pendingKey);
+    }
 
-        pendingPromise.then(function() {
-            return M.util.js_complete(pendingKey);
-        })
-        .catch();
+    /**
+     * Request a new pendingPromise for later resolution.
+     *
+     * When the action you are performing is complete, simply call resolve on the returned Promise.
+     *
+     * @param {String} [pendingKey='pendingPromise'] An identifier to help in debugging
+     * @return {Promise} A Native Promise
+     * @example
+     * import Pending from 'core/pending';
+     * import {get_string as getString} from 'core/str';
+     *
+     * const stringPromise = new Pending('mod_myexample/setup');
+     * const myString = getString('ok')
+     *     .then(okay => {
+     *         window.console.log(okay);
+     *     })
+     *     .then(okay => stringPromise.resolve(okay));
+     */
+    constructor(pendingKey = 'pendingPromise') {
+        let resolver;
+        let rejector;
+        const pendingPromise = this.constructor.Promise((resolve, reject) => {
+            resolver = resolve;
+            rejector = reject;
+        }, pendingKey);
+        pendingPromise.resolve = resolver;
+        pendingPromise.reject = rejector;
 
         return pendingPromise;
-    };
+    }
 
-    request.prototype.constructor = request;
+    /**
+     * Create a new Pending Promise with the same interface as a native Promise.
+     *
+     * @param {Callable} fn A callable which takes the resolve and reject arguments as in a Native Promise constructor.
+     * @param {String} [pendingKey='pendingPromise'] An identifier to help in debugging
+     * @returns {Promise}
+     * @since Moodle 4.2
+     * @example
+     * // Use the Pending class in the same way that you would a Native Promise.
+     * import Pending from 'core/pending';
+     * import {get_string as getString} from 'core/str';
+     *
+     * export const init => {
+     *     Pending.Promise((resolve, reject) => {
+     *         getString('ok')
+     *             .then(okay => {
+     *                 window.console.log(okay);
+     *                 return okay;
+     *             })
+     *             .then(resolve)
+     *             .catch(reject);
+     *     }, 'mod_myexample/setup:init');
+     * };
+     */
+    static Promise(fn, pendingKey = 'pendingPromise') {
+        const resolver = new Promise((resolve, reject) => {
+            M.util.js_pending(pendingKey);
 
-    return request;
-});
+            fn(resolve, reject);
+        });
+
+        resolver.then(() => {
+            M.util.js_complete(pendingKey);
+            return;
+        }).catch();
+
+        return resolver;
+    }
+}