jsf.js_next_gen 4.0.0-beta-13 → 4.0.0-beta-15

package/dist/window/jsf-development.js

@@ -62,27 +62,28 @@ var Submittables;
     Submittables["CHECKBOX"] = "checkbox";
 })(Submittables || (Submittables = {}));
 /**
- * helper to fix a common problem that a system has to wait until a certain condition is reached
- * depening on the browser this uses either the mutation observer or a semi compatible interval as fallback
- * @param root the root domquery element to start from
- * @param condition the condition lambda to be fullfilled
+ * helper to fix a common problem that a system has to wait, until a certain condition is reached.
+ * Depending on the browser this uses either the Mutation Observer or a semi compatible interval as fallback.
+ * @param root the root DomQuery element to start from
+ * @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 }) {
     return new Promise((success, error) => {
+        let observer = null;
         const MUT_ERROR = new Error("Mutation observer timeout");
         //we do the same but for now ignore the options on the dom query
         //we cannot use absent here, because the condition might search for an absent element
         function findElement(root, condition) {
             let found = null;
-            if (condition(root)) {
+            if (!!condition(root)) {
                 return root;
             }
             if (options.childList) {
-                found = (condition(root)) ? root : root.childNodes.first(condition).value.value;
+                found = (condition(root)) ? root : root.childNodes.filter(item => condition(item)).first().value.value;
             }
             else if (options.subtree) {
-                found = (condition(root)) ? root : root.querySelectorAll(" * ").first(condition).value;
+                found = (condition(root)) ? root : root.querySelectorAll(" * ").filter(item => condition(item)).first().value.value;
             }
             else {
                 found = (condition(root)) ? root : null;
@@ -90,22 +91,24 @@ function waitUntilDom(root, condition, options = { attributes: true, childList:
             return found;
         }
         let foundElement = root;
-        if ((foundElement = findElement(foundElement, condition)) != null) {
+        if (!!(foundElement = findElement(foundElement, condition))) {
             success(new DomQuery(foundElement));
             return;
         }
         if ('undefined' != typeof MutationObserver) {
             const mutTimeout = setTimeout(() => {
+                observer.disconnect();
                 return error(MUT_ERROR);
             }, options.timeout);
             const callback = (mutationList) => {
-                const found = new DomQuery(mutationList.map((mut) => mut.target)).first(condition);
-                if (found) {
+                const found = new DomQuery(mutationList.map((mut) => mut.target)).filter(item => condition(item)).first();
+                if (found.isPresent()) {
                     clearTimeout(mutTimeout);
-                    success(found);
+                    observer.disconnect();
+                    success(new DomQuery(found || root));
                 }
             };
-            const observer = new window.MutationObserver(callback);
+            observer = new window.MutationObserver(callback);
             // browsers might ignore it, but we cannot break the api in the case
             // hence no timeout is passed
             let observableOpts = Object.assign({}, options);
@@ -117,13 +120,13 @@ function waitUntilDom(root, condition, options = { attributes: true, childList:
         else { //fallback for legacy browsers without mutation observer
             let interval = setInterval(() => {
                 let found = findElement(root, condition);
-                if (found) {
+                if (!!found) {
                     if (timeout) {
                         clearTimeout(timeout);
                         clearInterval(interval);
                         interval = null;
-                        success(found);
                     }
+                    success(new DomQuery(found || root));
                 }
             }, options.interval);
             let timeout = setTimeout(() => {
@@ -1190,13 +1193,13 @@ class DomQuery {
      * defaults to the standard jsf.js exclusion (we use this code for myfaces)
      */
     runScripts(whilteListed = DEFAULT_WHITELIST) {
-        const evalCollectedScripts = (finalScripts) => {
-            if (finalScripts.length) {
+        const evalCollectedScripts = (scriptsToProcess) => {
+            if (scriptsToProcess.length) {
                 //script source means we have to eval the existing
                 //scripts before running the include
                 //this.globalEval(finalScripts.join("\n"));
                 let joinedScripts = [];
-                Stream_1.Stream.of(...finalScripts).each(item => {
+                Stream_1.Stream.of(...scriptsToProcess).each(item => {
                     if (!item.nonce) {
                         joinedScripts.push(item.evalText);
                     }
@@ -1212,8 +1215,9 @@ class DomQuery {
                     this.globalEval(joinedScripts.join("\n"));
                     joinedScripts.length = 0;
                 }
-                finalScripts = [];
+                scriptsToProcess = [];
             }
+            return scriptsToProcess;
         };
         let finalScripts = [], equi = equalsIgnoreCase, execScrpt = (item) => {
             var _a, _b, _c;
@@ -1234,7 +1238,7 @@ class DomQuery {
                     //if jsf.js is already registered we do not replace it anymore
                     if (whilteListed(src)) {
                         //we run the collected scripts before running, the include
-                        evalCollectedScripts(finalScripts);
+                        finalScripts = evalCollectedScripts(finalScripts);
                         (!!nonce) ? this.loadScriptEval(src, 0, "UTF-8", nonce) :
                             //if no nonce is set we do not pass any once
                             this.loadScriptEval(src, 0, "UTF-8");