jsf.js_next_gen 4.0.1-beta.5 → 4.0.1-beta.6

package/dist/window/faces-development.js

@@ -6570,14 +6570,9 @@ class XhrQueueController {
          * and clear the queue (theoretically this
          * would work with any promise)
          */
-        try {
-            return asyncRunnable
-                .then(() => this.next())
-                .catch((e) => this.handleError(e));
-        }
-        catch (e) {
-            this.handleError(e);
-        }
+        return asyncRunnable
+            .then(() => this.next())
+            .catch(() => this.clear());
     }
     /**
      * alerts the queue that a task is running
@@ -6594,16 +6589,6 @@ class XhrQueueController {
     updateTaskRunning() {
         this.taskRunning = !this.isEmpty;
     }
-    /**
-     * standard error handling
-     * we clear the queue and then bomb out
-     * @param e
-     * @private
-     */
-    handleError(e) {
-        this.clear();
-        throw e;
-    }
 }
 exports.XhrQueueController = XhrQueueController;
 
@@ -8046,8 +8031,10 @@ class XhrRequest extends AsyncRunnable_1.AsyncRunnable {
             this.sendRequest(formData);
         }
         catch (e) {
-            // _onError
-            this.handleError(e);
+            // this happens usually in a client side condition, hence we have to deal in with it in a client
+            // side manner
+            this.handleErrorAndClearQueue(e);
+            throw e;
         }
         return this;
     }
@@ -8071,102 +8058,138 @@ class XhrRequest extends AsyncRunnable_1.AsyncRunnable {
     registerXhrCallbacks(resolve, reject) {
         const xhrObject = this.xhrObject;
         xhrObject.onabort = () => {
-            this.onAbort(reject);
+            this.onAbort(resolve, reject);
         };
         xhrObject.ontimeout = () => {
-            this.onTimeout(reject);
+            this.onTimeout(resolve, reject);
         };
         xhrObject.onload = () => {
-            this.onSuccess(resolve);
+            this.onResponseReceived(resolve);
         };
         xhrObject.onloadend = () => {
-            this.onDone(this.xhrObject, resolve);
+            this.onResponseProcessed(this.xhrObject, resolve);
         };
         xhrObject.onerror = (errorData) => {
-            // some browsers trigger an error when cancelling a request internally, or when
-            // cancel is called from outside
+            // Safari in rare cases triggers an error when cancelling a request internally, or when
             // in this case we simply ignore the request and clear up the queue, because
             // it is not safe anymore to proceed with the current queue
             // This bypasses a Safari issue where it keeps requests hanging after page unload
             // and then triggers a cancel error on then instead of just stopping
             // and clearing the code
+            // in a page unload case it is safe to clear the queue
+            // in the exact safari case any request after this one in the queue is invalid
+            // because the queue references xhr requests to a page which already is gone!
             if (this.isCancelledResponse(this.xhrObject)) {
                 /*
                  * this triggers the catch chain and after that finally
                  */
-                reject();
                 this.stopProgress = true;
+                reject();
                 return;
             }
-            this.onError(errorData, reject);
+            // error already processed somewhere else
+            if (this.stopProgress) {
+                return;
+            }
+            this.handleError(errorData);
         };
     }
     isCancelledResponse(currentTarget) {
-        return (currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.status) === 0 && // cancelled by browser
+        return (currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.status) === 0 && // cancelled internally by browser
             (currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.readyState) === 4 &&
             (currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.responseText) === '' &&
             (currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget.responseXML) === null;
     }
     /*
-         * xhr processing callbacks
-         *
-         * Those methods are the callbacks called by
-         * the xhr object depending on its own state
-         */
-    onAbort(reject) {
-        reject();
+     * xhr processing callbacks
+     *
+     * Those methods are the callbacks called by
+     * the xhr object depending on its own state
+     */
+    /**
+     * client side abort... also here for now we clean the queue
+     *
+     * @param resolve
+     * @param reject
+     * @private
+     */
+    onAbort(resolve, reject) {
+        // reject means clear queue, in this case we abort entirely the processing
+        // does not happen yet, we have to probably rethink this strategy in the future
+        // when we introduce cancel functionality
+        this.handleGenericError(reject);
     }
-    onTimeout(reject) {
+    /**
+     * request timeout, this must be handled like a generic server error per spec
+     * unfortunately, so we have to jump to the next item (we cancelled before)
+     * @param resolve
+     * @param reject
+     * @private
+     */
+    onTimeout(resolve, reject) {
+        // timeout also means we we probably should clear the queue,
+        // the state is unsafe for the next requests
         this.sendEvent(Const_1.STATE_EVT_TIMEOUT);
-        reject();
+        this.handleGenericError(resolve);
     }
-    onSuccess(resolve) {
-        var _a, _b;
+    /**
+     * the response is received and normally is a normal response
+     * but also can be some kind of error (http code >= 300)
+     * In any case the response will be resolved either as error or response
+     * and the next item in the queue will be processed
+     * @param resolve
+     * @private
+     */
+    onResponseReceived(resolve) {
+        var _a, _b, _c, _d;
         this.sendEvent(Const_1.COMPLETE);
-        // malformed responses always result in empty response xml
-        // per spec a valid response cannot be empty
-        if (!((_a = this === null || this === void 0 ? void 0 : this.xhrObject) === null || _a === void 0 ? void 0 : _a.responseXML)) {
-            this.handleMalFormedXML(resolve);
+        /*
+         * second on error path
+         */
+        if (((_b = (_a = this.xhrObject) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 0) >= 300 || !((_c = this === null || this === void 0 ? void 0 : this.xhrObject) === null || _c === void 0 ? void 0 : _c.responseXML)) {
+            // all errors from the server are resolved without interfering in the queue
+            this.handleGenericError(resolve);
             return;
         }
-        (0, Const_1.$faces)().ajax.response(this.xhrObject, (_b = this.responseContext.value) !== null && _b !== void 0 ? _b : {});
+        (0, Const_1.$faces)().ajax.response(this.xhrObject, (_d = this.responseContext.value) !== null && _d !== void 0 ? _d : {});
     }
-    handleMalFormedXML(resolve) {
-        var _a;
+    handleGenericError(resolveOrReject) {
+        var _a, _b, _c, _d;
         this.stopProgress = true;
         const errorData = {
             type: Const_1.ERROR,
             status: Const_1.MALFORMEDXML,
-            responseCode: 200,
-            responseText: (_a = this.xhrObject) === null || _a === void 0 ? void 0 : _a.responseText,
+            responseCode: (_b = (_a = this.xhrObject) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 400,
+            responseText: (_d = (_c = this.xhrObject) === null || _c === void 0 ? void 0 : _c.responseText) !== null && _d !== void 0 ? _d : "Error",
             source: this.internalContext.getIf(Const_1.CTX_PARAM_SRC_CTL_ID).value
         };
         try {
             this.handleError(errorData, true);
         }
         finally {
-            // we issue a resolve in this case to allow the system to recover
+            // we issue a resolveOrReject in this case to allow the system to recover
             // reject would clean up the queue
-            resolve(errorData);
+            // resolve would trigger the next element in the queue to be processed
+            resolveOrReject(errorData);
         }
         // non blocking non clearing
     }
-    onDone(data, resolve) {
-        // if stop progress a special handling including resolve is already performed
+    /**
+     * last minute cleanup, the request now either is fully done
+     * or not by having had a cancel or error event be
+     * @param data
+     * @param resolve
+     * @private
+     */
+    onResponseProcessed(data, resolve) {
+        // if stop progress true, the cleanup already has been performed
         if (this.stopProgress) {
             return;
         }
-        /**
-         * now call the then chain
-         */
-        resolve(data);
-    }
-    onError(errorData, reject) {
-        this.handleError(errorData);
         /*
-         * this triggers the catch chain and after that finally
+         * normal case, cleanup == next item if possible
          */
-        reject();
+        resolve(data);
     }
     sendRequest(formData) {
         const isPost = this.ajaxType != Const_1.REQ_TYPE_GET;
@@ -8195,10 +8218,16 @@ class XhrRequest extends AsyncRunnable_1.AsyncRunnable {
         }
         catch (e) {
             e.source = (_a = e === null || e === void 0 ? void 0 : e.source) !== null && _a !== void 0 ? _a : this.requestContext.getIf(Const_1.SOURCE).value;
-            this.handleError(e);
+            // this is a client error, no save state anymore for queue processing!
+            this.handleErrorAndClearQueue(e);
+            // we forward the error upward like all client side errors
             throw e;
         }
     }
+    handleErrorAndClearQueue(e, responseFormatError = false) {
+        this.handleError(e, responseFormatError);
+        this.reject(e);
+    }
     handleError(exception, responseFormatError = false) {
         const errorData = (responseFormatError) ? ErrorData_1.ErrorData.fromHttpConnection(exception.source, exception.type, exception.status, exception.responseText, exception.responseCode, exception.status) : ErrorData_1.ErrorData.fromClient(exception);
         const eventHandler = (0, RequestDataResolver_1.resolveHandlerFunc)(this.requestContext, this.responseContext, Const_1.ON_ERROR);