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

package/dist/window/jsf-development.js

@@ -248,7 +248,7 @@ function simpleShallowMerge(...assocArrays) {
 }
 exports.simpleShallowMerge = simpleShallowMerge;
 /**
- * Shallow merge as in config
+ * Shallow merge as in config, but on raw associative arrays
  *
  * @param overwrite
  * @param withAppend
@@ -1859,33 +1859,19 @@ class DomQuery {
         const execCss = (toReplace) => {
             const _toReplace = DomQuery.byId(toReplace);
             const tagName = _toReplace.tagName.orElse("").value;
-            const head = DomQuery.byTagName("head");
-            if (tagName && eqi(tagName, "link") && eqi(toReplace.getAttribute("rel"), "stylesheet")) {
-                const rel = toReplace.getAttribute("rel");
-                //if possible we are now replacing the existing elements where we reference this stylesheet
-                const matches = head.querySelectorAll(`link[rel='stylesheet'][href='${rel}']`);
-                if (matches.length) {
-                    matches.replace(_toReplace);
-                }
-                else {
-                    head.append(_toReplace);
-                }
-            }
-            else if (tagName && eqi(tagName, "style")) {
-                let innerText = _toReplace.innerHTML.replace(/\s+/gi, "");
-                let styles = head.querySelectorAll("style");
-                let filteredStyles = styles.asArray.filter(style => {
-                    return style.innerHTML.replace(/\s+/gi, "") == innerText;
-                });
-                styles = new DomQuery(...filteredStyles);
-                if (!styles.length) { //already present
-                    head.append(_toReplace);
-                }
-            }
+            let newElement = DomQuery.fromMarkup(`<${tagName.toLowerCase()} />`);
+            newElement = newElement.copyAttrs(_toReplace);
+            newElement.innerHTML = toReplace.innerHTML;
+            // css suffices a simple replace to get it eval-ed, no need
+            // for a full head replace
+            _toReplace.replace(newElement);
         };
         const scriptElements = new DomQuery(this.filterSelector("link, style"), this.querySelectorAll("link, style"));
         scriptElements.asArray
             .flatMap(item => [...item.values])
+            // sort to make sure the execution order is correct
+            // this is needed because we mix 2 queries together
+            // -3 is needed due to the compareDocumentPosition return value
             .sort((node1, node2) => node1.compareDocumentPosition(node2) - 3)
             .forEach(item => execCss(item));
         return this;
@@ -2482,12 +2468,12 @@ class DomQuery {
         }
     }
 }
-exports.DomQuery = DomQuery;
 DomQuery.absent = new DomQuery();
 /**
  * reference to the environmental global object
  */
 DomQuery.global = Global_1._global$;
+exports.DomQuery = DomQuery;
 /**
  * Various collectors
  * which can be used in conjunction with Streams
@@ -2642,7 +2628,12 @@ exports._Es2019Array = _Es2019Array;
  * does not yet have flatMap support on arrays
  */
 exports.Es2019Array = (Array.prototype.flatMap) ? function (...data) {
-    return data;
+    // sometimes the typescript compiler produces
+    // an array without flatmap between boundaries (the result produces True for Array.isArray
+    // but has no flatMap function, could be a node issue also or Typescript!
+    // we remap that (could be related to: https://github.com/microsoft/TypeScript/issues/31033
+    // the check and remap fixes the issue which should not exist in the first place
+    return (data === null || data === void 0 ? void 0 : data.flatMap) ? data : _Es2019Array(...data);
 } : _Es2019Array;
 
 
@@ -3164,9 +3155,9 @@ class Optional extends Monad {
         });
     }
 }
-exports.Optional = Optional;
 /*default value for absent*/
 Optional.absent = Optional.fromNullable(null);
+exports.Optional = Optional;
 // --------------------- From here onwards we break out the side effect free limits ------------
 /**
  * ValueEmbedder is the writeable version
@@ -3219,9 +3210,9 @@ class ValueEmbedder extends Optional {
         return new ValueEmbedder(value, valueKey);
     }
 }
-exports.ValueEmbedder = ValueEmbedder;
 /*default value for absent*/
 ValueEmbedder.absent = ValueEmbedder.fromNullable(null);
+exports.ValueEmbedder = ValueEmbedder;
 
 
 /***/ }),
@@ -6570,14 +6561,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 +6580,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 +8022,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 +8049,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;
+            }
+            // error already processed somewhere else
+            if (this.stopProgress) {
                 return;
             }
-            this.onError(errorData, reject);
+            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 +8209,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);