jsf.js_next_gen 4.0.0-beta-20 → 4.0.0-beta-22

package/dist/window/faces-development.js

@@ -69,7 +69,13 @@ var Submittables;
  * @param condition the condition lambda to be fulfilled
  * @param options options for the search
  */
-function waitUntilDom(root, condition, options = { attributes: true, childList: true, subtree: true, timeout: 500, interval: 100 }) {
+function waitUntilDom(root, condition, options = {
+    attributes: true,
+    childList: true,
+    subtree: true,
+    timeout: 500,
+    interval: 100
+}) {
     return new Promise((success, error) => {
         let observer = null;
         const MUT_ERROR = new Error("Mutation observer timeout");
@@ -1029,33 +1035,8 @@ class DomQuery {
      * @param defer in miliseconds execution default (0 == no defer)
      * @param charSet
      */
-    loadScriptEval(src, defer = 0, charSet = "utf-8", nonce) {
-        let xhr = new XMLHttpRequest();
-        xhr.open("GET", src, false);
-        if (charSet) {
-            xhr.setRequestHeader("Content-Type", "application/x-javascript; charset:" + charSet);
-        }
-        xhr.onload = () => {
-            //defer also means we have to process after the ajax response
-            //has been processed
-            //we can achieve that with a small timeout, the timeout
-            //triggers after the processing is done!
-            if (!defer) {
-                this.globalEval(xhr.responseText.replace(/\n/g, "\r\n") + "\r\n//@ sourceURL=" + src, nonce);
-            }
-            else {
-                //TODO not ideal we maybe ought to move to something else here
-                //but since it is not in use yet, it is ok
-                setTimeout(() => {
-                    this.globalEval(xhr.responseText + "\r\n//@ sourceURL=" + src, nonce);
-                }, defer);
-            }
-        };
-        xhr.onerror = (data) => {
-            throw Error(data);
-        };
-        //since we are synchronous we do it after not with onReadyStateChange
-        xhr.send(null);
+    loadScriptEval(src, defer = 0, nonce) {
+        this._loadScriptEval(false, src, defer, nonce);
         return this;
     }
     /**
@@ -1065,33 +1046,46 @@ class DomQuery {
      * @param defer in miliseconds execution default (0 == no defer)
      * @param charSet
      */
-    loadScriptEvalSticky(src, defer = 0, charSet = "utf-8", nonce) {
-        let xhr = new XMLHttpRequest();
-        xhr.open("GET", src, false);
-        if (charSet) {
-            xhr.setRequestHeader("Content-Type", "application/x-javascript; charset:" + charSet);
-        }
-        xhr.onload = () => {
-            //defer also means we have to process after the ajax response
-            //has been processed
-            //we can achieve that with a small timeout, the timeout
-            //triggers after the processing is done!
+    loadScriptEvalSticky(src, defer = 0, nonce) {
+        this._loadScriptEval(true, src, defer, nonce);
+        return this;
+    }
+    _loadScriptEval(sticky, src, defer = 0, nonce) {
+        let srcNode = this.createSourceNode(src, nonce);
+        let nonceCheck = this.createSourceNode(null, nonce);
+        let marker = `nonce_${Date.now()}_${Math.random()}`;
+        nonceCheck.innerHTML = `document.head["${marker}"] = true`; //noop
+        let head = document.head;
+        //  upfront nonce check, needed mostly for testing
+        //  but cannot hurt to block src calls which have invalid nonce on localhost
+        // the reason for doing this up until now we have a similar construct automatically
+        // by loading the scripts via xhr and then embedding them.
+        // this is not needed anymore but the nonce is more relaxed with script src
+        // we now enforce it the old way
+        head.appendChild(nonceCheck);
+        head.removeChild(nonceCheck);
+        if (!head[marker]) {
+            return;
+        }
+        try {
             if (!defer) {
-                this.globalEvalSticky(xhr.responseText.replace(/\n/g, "\r\n") + "\r\n//@ sourceURL=" + src, nonce);
+                head.appendChild(srcNode);
+                if (!sticky) {
+                    head.removeChild(srcNode);
+                }
             }
             else {
-                //TODO not ideal we maybe ought to move to something else here
-                //but since it is not in use yet, it is ok
                 setTimeout(() => {
-                    this.globalEvalSticky(xhr.responseText + "\r\n//@ sourceURL=" + src, nonce);
+                    head.appendChild(srcNode);
+                    if (!sticky) {
+                        head.removeChild(srcNode);
+                    }
                 }, defer);
             }
-        };
-        xhr.onerror = (data) => {
-            throw Error(data);
-        };
-        //since we are synchronous we do it after not with onReadyStateChange
-        xhr.send(null);
+        }
+        finally {
+            delete head[marker];
+        }
         return this;
     }
     insertAfter(...toInsertParams) {
@@ -1309,14 +1303,14 @@ class DomQuery {
                         //we run the collected scripts before running, the include
                         finalScripts = evalCollectedScripts(finalScripts);
                         if (!sticky) {
-                            (!!nonce) ? this.loadScriptEval(src, 0, "UTF-8", nonce) :
+                            (!!nonce) ? this.loadScriptEval(src, 0, nonce) :
                                 //if no nonce is set we do not pass any once
-                                this.loadScriptEval(src, 0, "UTF-8");
+                                this.loadScriptEval(src, 0);
                         }
                         else {
-                            (!!nonce) ? this.loadScriptEvalSticky(src, 0, "UTF-8", nonce) :
+                            (!!nonce) ? this.loadScriptEvalSticky(src, 0, nonce) :
                                 //if no nonce is set we do not pass any once
-                                this.loadScriptEvalSticky(src, 0, "UTF-8");
+                                this.loadScriptEvalSticky(src, 0);
                         }
                     }
                 }
@@ -1665,7 +1659,13 @@ class DomQuery {
      * @param condition
      * @param options
      */
-    waitUntilDom(condition, options = { attributes: true, childList: true, subtree: true, timeout: 500, interval: 100 }) {
+    waitUntilDom(condition, options = {
+        attributes: true,
+        childList: true,
+        subtree: true,
+        timeout: 500,
+        interval: 100
+    }) {
         return __awaiter(this, void 0, void 0, function* () {
             return waitUntilDom(this, condition, options);
         });
@@ -1781,6 +1781,51 @@ class DomQuery {
         });
         return this;
     }
+    /*[observable](): Observable<DomQuery> {
+        return this.observable;
+    }
+
+    get observable(): Observable<DomQuery> {
+        let observerFunc = (observer:Subscriber<DomQuery>) => {
+            try {
+                this.each(dqNode => {
+                    observer.next(dqNode);
+                });
+            } catch (e) {
+                observer.error(e);
+            }
+        };
+        return new Observable(observerFunc);
+    }
+
+    get observableElem(): Observable<Element> {
+        let observerFunc = (observer:Subscriber<Element>) => {
+            try {
+                this.eachElem(node => {
+                    observer.next(node);
+                });
+            } catch (e) {
+                observer.error(e);
+            }
+        };
+        return new Observable(observerFunc);
+    }*/
+    createSourceNode(src, nonce) {
+        let srcNode = document.createElement("script");
+        srcNode.type = "text/javascript";
+        if (!!nonce) {
+            if ('undefined' != typeof (srcNode === null || srcNode === void 0 ? void 0 : srcNode.nonce)) {
+                srcNode.nonce = nonce;
+            }
+            else {
+                srcNode.setAttribute("nonce", nonce);
+            }
+        }
+        if (!!src) {
+            srcNode.src = src;
+        }
+        return srcNode;
+    }
 }
 exports.DomQuery = DomQuery;
 DomQuery.absent = new DomQuery();
@@ -5380,7 +5425,7 @@ const IS_FACES_SOURCE = (source) => {
 };
 /**
  * namespace myfaces.testscripts can be used as extension point for internal
- * tests, those will be handled similarly to faces.js regarding
+ * tests, those will be handled similarly to faces.js - regarding
  * reload blocking on ajax requests
  *
  * @param source the source to check
@@ -5490,6 +5535,7 @@ class ExtDomquery extends mona_dish_1.DQ {
     /**
      * decorated run scripts which takes our jsf extensions into consideration
      * (standard DomQuery will let you pass anything)
+     * @param sticky if set to true the internally generated element for the script is left in the dom
      * @param whilteListed
      */
     runScripts(sticky = false, whilteListed) {
@@ -5497,7 +5543,51 @@ class ExtDomquery extends mona_dish_1.DQ {
             var _a;
             return ((_a = whilteListed === null || whilteListed === void 0 ? void 0 : whilteListed(src)) !== null && _a !== void 0 ? _a : true) && !IS_FACES_SOURCE(src) && !IS_INTERNAL_SOURCE(src);
         };
-        return super.runScripts(false, whitelistFunc);
+        return super.runScripts(sticky, whitelistFunc);
+    }
+    /**
+     * adds the elements in this ExtDomQuery to the head
+     *
+     * @param suppressDoubleIncludes checks for existing elements in the head before running the insert
+     */
+    runHeadInserts(suppressDoubleIncludes = true) {
+        let head = ExtDomquery.byId(document.head);
+        //automated nonce handling
+        let processedScripts = [];
+        // the idea is only to run head inserts on resources
+        // which do not exist already, that way
+        // we can avoid double includes on subsequent resource
+        // requests.
+        function resourceIsNew(element) {
+            if (!suppressDoubleIncludes) {
+                return true;
+            }
+            const tagName = element.tagName.value;
+            if (!tagName) {
+                // textnode
+                return true;
+            }
+            let href = element.attr("href").orElse(element.attr("src").value);
+            if (!href.isPresent()) {
+                return true;
+            }
+            return !head.querySelectorAll(`${tagName}[href='${href.value}']`).length &&
+                !head.querySelectorAll(`${tagName}[src='${href.value}']`).length;
+        }
+        this
+            .filter(resourceIsNew)
+            .each(element => {
+            if (element.tagName.value != "SCRIPT") {
+                //we need to run runScripts properly to deal with the rest
+                new ExtDomquery(...processedScripts).runScripts(true);
+                processedScripts = [];
+                head.append(element);
+            }
+            else {
+                processedScripts.push(element);
+            }
+        });
+        new ExtDomquery(...processedScripts).runScripts(true);
     }
     /**
      * byId producer
@@ -6633,7 +6723,7 @@ class ResponseProcessor {
     globalEval() {
         //  phase one, if we have head inserts, we build up those before going into the script eval phase
         let insertHeadElems = new ExtDomQuery_1.ExtDomquery(...this.internalContext.getIf(Const_1.DEFERRED_HEAD_INSERTS).value);
-        this.runHeadInserts(insertHeadElems);
+        insertHeadElems.runHeadInserts(true);
         // phase 2 we run a script eval on all updated elements in the body
         let updateElems = new ExtDomQuery_1.ExtDomquery(...this.internalContext.getIf(Const_1.UPDATE_ELEMS).value);
         updateElems.runCss();
@@ -6783,28 +6873,6 @@ class ResponseProcessor {
     triggerOnError(errorData) {
         this.externalContext.getIf(Const_1.ON_ERROR).orElse(this.internalContext.getIf(Const_1.ON_ERROR).value).orElse(Const_1.EMPTY_FUNC).value(errorData);
     }
-    /**
-     * adds new elements to the head as per spec, we use it in a deferred way
-     * to have the html buildup first then the head inserts which run the head evals
-     * and then the body and css evals from the markup
-     *
-     * This is only performed upon a head replacement or resource insert
-     *
-     * @param newElements the elements which need addition
-     */
-    runHeadInserts(newElements) {
-        let head = ExtDomQuery_1.ExtDomquery.byId(document.head);
-        //automated nonce handling
-        newElements.each(element => {
-            if (element.tagName.value != "SCRIPT" || element.attr("src").isPresent()) {
-                head.append(element);
-                return;
-            }
-            // special corner case
-            // embedded script code,
-            element.globalEvalSticky(element.innerHTML);
-        });
-    }
 }
 exports.ResponseProcessor = ResponseProcessor;