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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.0.1-beta.4",
+  "version": "4.0.1-beta.6",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/faces.js",
   "scripts": {

package/src/main/typescript/impl/util/FileUtils.ts

@@ -104,5 +104,5 @@ function resolveViewState(parentItem: DomQuery): string[][] | [string, File][] {
 export function getFormInputsAsArr(parentItem: DomQuery): string[][] | [string, File][] {
     const standardInputs: any = resolveViewState(parentItem);
     const fileInputs = resolveFiles(parentItem);
-    return standardInputs.concat(...fileInputs)
+    return standardInputs.concat(fileInputs)
 }

package/src/main/typescript/impl/util/XhrQueueController.ts

@@ -72,13 +72,9 @@ export class XhrQueueController<T extends IAsyncRunnable<any>> {
          * 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());
     }
 
 
@@ -99,14 +95,4 @@ export class XhrQueueController<T extends IAsyncRunnable<any>> {
         this.taskRunning = !this.isEmpty;
     }
 
-    /**
-     * standard error handling
-     * we clear the queue and then bomb out
-     * @param e
-     * @private
-     */
-    private handleError(e) {
-        this.clear();
-        throw e;
-    }
 }

package/src/main/typescript/impl/xhrCore/ResponseProcessor.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import {Config, DomQuery, DomQueryCollector, DQ, DQ$, Lang, XMLQuery} from "mona-dish";
+import {Config, DomQuery, DQ, DQ$, Lang, XMLQuery} from "mona-dish";
 import {Implementation} from "../AjaxImpl";
 import {Assertions} from "../util/Assertions";
 import {IResponseProcessor} from "./IResponseProcessor";
@@ -115,8 +115,8 @@ export class ResponseProcessor implements IResponseProcessor {
         const nodesToAdd = (shadowHead.tagName.value === "HEAD") ? shadowHead.childNodes : shadowHead;
         // this is stored for "post" processing
         // after the rest of the "physical build up", head before body
-        const scriptElements = nodesToAdd.stream
-            .filter(item => scriptTags.indexOf(item.tagName.orElse("").value) != -1).collect(new DomQueryCollector());
+        const scriptElements = new DomQuery(...nodesToAdd.asArray
+            .filter(item => scriptTags.indexOf(item.tagName.orElse("").value) != -1));
 
         this.addToHeadDeferred(scriptElements);
     }
@@ -366,7 +366,7 @@ export class ResponseProcessor implements IResponseProcessor {
      * is done.
      */
     fixClientWindow() {
-       ofAssoc(this.internalContext.getIf(APPLIED_CLIENT_WINDOW).orElse({}).value)
+        ofAssoc(this.internalContext.getIf(APPLIED_CLIENT_WINDOW).orElse({}).value)
             .forEach(([, value]) => {
                 const namingContainerId = this.internalContext.getIf(NAMING_CONTAINER_ID);
                 const namedViewRoot = !!this.internalContext.getIf(NAMED_VIEWROOT).value;

package/src/main/typescript/impl/xhrCore/XhrRequest.ts

@@ -41,7 +41,7 @@ import {
     STATE_EVT_TIMEOUT,
     STD_ACCEPT,
     URL_ENCODED,
-    VAL_AJAX, IDENT_NONE, CTX_PARAM_SRC_FRM_ID, CTX_PARAM_SRC_CTL_ID, CTX_PARAM_PPS
+    VAL_AJAX, IDENT_NONE, CTX_PARAM_SRC_FRM_ID, CTX_PARAM_SRC_CTL_ID, CTX_PARAM_PPS, SERVER_ERROR
 } from "../core/Const";
 import {
     resolveFinalUrl,
@@ -74,6 +74,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
 
 
     private xhrObject = new XMLHttpRequest();
+
     /**
      * Required Parameters
      *
@@ -167,7 +168,7 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             // a bug in the xhr stub library prevents the setRequestHeader to be properly executed on fake xhr objects
             // normal browsers should resolve this
             // tests can quietly fail on this one
-            if(this.contentType != "undefined") {
+            if (this.contentType != "undefined") {
                 ignoreErr(() => xhrObject.setRequestHeader(CONTENT_TYPE, `${this.contentType}; charset=utf-8`));
             }
 
@@ -181,12 +182,16 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             this.sendEvent(BEGIN);
             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;
     }
 
+
+
     cancel() {
         try {
             // this causes onError to be called where the error
@@ -198,7 +203,6 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
     }
 
 
-
     /**
      * attaches the internal event and processing
      * callback within the promise to our xhr object
@@ -210,111 +214,144 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
         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: any) => {
-
-            // 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
-            if(this.isCancelledResponse(this.xhrObject)) {
+            // 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);
         };
     }
 
     private isCancelledResponse(currentTarget: XMLHttpRequest): boolean {
-        return currentTarget?.status === 0 && // cancelled by browser
+        return currentTarget?.status === 0 && // cancelled internally by browser
             currentTarget?.readyState === 4 &&
             currentTarget?.responseText === '' &&
             currentTarget?.responseXML === null;
     }
 
     /*
-         * xhr processing callbacks
-         *
-         * Those methods are the callbacks called by
-         * the xhr object depending on its own state
-         */
-
-    private onAbort(reject: Consumer<any>) {
-        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
+     */
+    private onAbort(resolve: Consumer<any>, reject: Consumer<any>) {
+        // 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);
     }
 
-    private onTimeout(reject: Consumer<any>) {
+    /**
+     * 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
+     */
+    private onTimeout(resolve: Consumer<any>, reject: Consumer<any>) {
+        // timeout also means we we probably should clear the queue,
+        // the state is unsafe for the next requests
         this.sendEvent(STATE_EVT_TIMEOUT);
-        reject();
+        this.handleGenericError(resolve);
     }
 
-    private onSuccess(resolve: Consumer<any>) {
+    /**
+     * 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
+     */
+    private onResponseReceived(resolve: Consumer<any>) {
 
         this.sendEvent(COMPLETE);
-
-        // malformed responses always result in empty response xml
-        // per spec a valid response cannot be empty
-        if (!this?.xhrObject?.responseXML) {
-            this.handleMalFormedXML(resolve);
+        /*
+         * second on error path
+         */
+        if ((this.xhrObject?.status ?? 0) >= 300 || !this?.xhrObject?.responseXML) {
+            // all errors from the server are resolved without interfering in the queue
+            this.handleGenericError(resolve);
             return;
         }
 
         $faces().ajax.response(this.xhrObject, this.responseContext.value ?? {});
     }
 
-    private handleMalFormedXML(resolve: Function) {
+    private handleGenericError(resolveOrReject: Function) {
         this.stopProgress = true;
         const errorData = {
             type: ERROR,
             status: MALFORMEDXML,
-            responseCode: 200,
-            responseText: this.xhrObject?.responseText,
-            source:  this.internalContext.getIf(CTX_PARAM_SRC_CTL_ID).value
+            responseCode: this.xhrObject?.status ?? 400,
+            responseText: this.xhrObject?.responseText ?? "Error",
+            source: this.internalContext.getIf(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
     }
 
-    private onDone(data: any, resolve: Consumer<any>) {
-        // 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
+     */
+    private onResponseProcessed(data: any, resolve: Consumer<any>) {
+        // if stop progress true, the cleanup already has been performed
         if (this.stopProgress) {
             return;
         }
-        /**
-         * now call the then chain
-         */
-        resolve(data);
-    }
-
-    private onError(errorData: any,  reject: Consumer<any>) {
-        this.handleError(errorData);
         /*
-         * this triggers the catch chain and after that finally
+         * normal case, cleanup == next item if possible
          */
-        reject();
+        resolve(data);
     }
 
     private sendRequest(formData: XhrFormData) {
@@ -343,12 +380,18 @@ export class XhrRequest extends AsyncRunnable<XMLHttpRequest> {
             Implementation.sendEvent(eventData, eventHandler);
         } catch (e) {
             e.source = e?.source ?? this.requestContext.getIf(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;
         }
     }
 
+    private handleErrorAndClearQueue(e, responseFormatError: boolean = false) {
+        this.handleError(e, responseFormatError);
+        this.reject(e);
+    }
+
     private handleError(exception, responseFormatError: boolean = false) {
         const errorData = (responseFormatError) ? ErrorData.fromHttpConnection(exception.source, exception.type, exception.status, exception.responseText, exception.responseCode, exception.status) : ErrorData.fromClient(exception);
         const eventHandler = resolveHandlerFunc(this.requestContext, this.responseContext, ON_ERROR);

package/src/main/typescript/test/frameworkBase/_ext/monadish/DomQueryTest.spec.ts

@@ -17,7 +17,7 @@
 import {expect} from 'chai';
 import {describe, it} from 'mocha';
 import {from} from "rxjs";
-import {ArrayCollector, Config, DomQuery, DomQueryCollector, Lang, LazyStream, Stream} from "mona-dish";
+import {ArrayCollector, Config, DomQuery, DomQueryCollector, Lang, LazyStream, Stream} from "mona-dish/dist/js/umd";
 import {tobagoSheetWithHeader} from "./markups/tobago-with-header";
 import {tobagoSheetWithoutHeader} from "./markups/tobago-without-header";
 

package/src/main/typescript/test/frameworkBase/_ext/monadish/fixtures/blank.css

@@ -0,0 +1,15 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */

package/src/main/typescript/test/frameworkBase/_ext/monadish/fixtures/test.js

@@ -1 +1,16 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 document.getElementById('id_1').innerHTML = "hello world";

package/src/main/typescript/test/frameworkBase/_ext/monadish/fixtures/test2.js

@@ -1 +1,16 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 document.getElementById('id_1').innerHTML = "hello world";

package/src/main/typescript/test/frameworkBase/_ext/shared/StandardInits.ts

@@ -236,6 +236,42 @@ export module StandardInits {
     `;
     }
 
+    export const ERROR_CHAIN_PAGE = `
+    <!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+<h2>Error Chain Testcase</h2>
+<script type="text/javascript">
+/**
+* code identical to mojarra test, both stem from me
+* so mojarras side EPL here ASL2!
+* 
+* @param event
+*/
+function triggerRequestChain(event) {
+    for(let cnt = 0; cnt < 5; cnt++) {
+        faces.ajax.request(event.target, "click", {
+            render:"form1",
+            onerror: function() {
+                document.getElementById("errorCalled").innerHTML = "1";
+            }
+        })
+    }
+}
+</script>
+<div id="errorCalled"></div>
+<form id="form1">
+    <div id="form1:out1">0</div>
+    <input type="button" id="form1:button1" onclick="triggerRequestChain(event)">
+</form>
+</body>
+</html>
+    `;
+
     /**
      * This is a standardized small page mockup
      * testing the various aspects of the protocol
@@ -405,6 +441,10 @@ export module StandardInits {
         return <any>init((IS_40) ? PROTOCOL_PAGE : PROTOCOL_PAGE.replace(/jakarta/gi,"javax"), withJsf, IS_40);
     }
 
+    export function errorChainPage(withJsf = true, IS_40 = true): Promise<() => void> {
+        return <any>init((IS_40) ? ERROR_CHAIN_PAGE : ERROR_CHAIN_PAGE.replace(/jakarta/gi,"javax"), withJsf, IS_40);
+    }
+
     export function prefixEmbeddedPage(withJsf = true, IS_40 = true): Promise<() => void> {
         return <any>init((IS_40) ? HTML_FORM_PREFIXED_EMBEDDED : HTML_FORM_PREFIXED_EMBEDDED.replace(/jakarta/gi,"javax"), withJsf, IS_40);
     }

package/src/main/typescript/test/frameworkBase/_ext/shared/XmlResponses.ts

@@ -250,4 +250,11 @@ export class XmlResponses {
     `;
 
     static ILLEGAL_RESP = `>>>> xxxx >YYYY-!->>>`;
+
+
+    static  ERROR_CHAIN_RESPOND_OK = (cnt: number): string => {
+        return `<partial-response><changes><update id='form1:out1'><![CDATA[<div id="form1:out1">${cnt}</div>]]>
+    </update></changes></partial-response>`;
+    }
+
 }

package/src/main/typescript/test/frameworkBase/_ext/shared/fixtures/jakarta.faces.resource/faces.js.jsf

@@ -0,0 +1,15 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements.  See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to you under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License.  You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/

package/src/main/typescript/test/myfaces/{OnLoadSpec.ts → OnLoad.spec.ts}

@@ -33,10 +33,10 @@ describe('Tests on the xhr core when it starts to call the request', function ()
         return
     });
 
-    it("must be present", async function(done)  {
+    it("must be present", async function()  {
         await defaultMyFaces();
         expect(myfaces?.onDomReady).to.exist;
-        done();
+        return true;
     });
 
     it("must be called on onDocumentReady", async function(done) {

package/src/main/typescript/test/xhrCore/ErrorChainTest.spec.ts

@@ -0,0 +1,113 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+import {describe} from "mocha";
+import * as sinon from "sinon";
+import {$nsp} from "../../impl/core/Const";
+import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
+import {XmlResponses} from "../frameworkBase/_ext/shared/XmlResponses";
+import {expect} from "chai";
+import {Implementation} from "../../impl/AjaxImpl";
+import errorChainPage = StandardInits.errorChainPage;
+import {DQ} from "mona-dish";
+
+/**
+ * Tests for error recover if an error is triggered mid chain
+ */
+describe('Tests of the various aspects of the response protocol functionality', function () {
+
+    beforeEach(async function () {
+        let waitForResult = errorChainPage(true);
+        return waitForResult.then((close) => {
+
+            this.xhr = sinon.useFakeXMLHttpRequest();
+            this.requests = [];
+
+            this.respond = (response: string): XMLHttpRequest => {
+                response = $nsp(response);
+                let xhrReq = this.requests.shift();
+                xhrReq.responsetype = "text/xml";
+                xhrReq.respond(200, {'Content-Type': 'text/xml'}, response);
+                return xhrReq;
+            };
+
+            this.respond403 = (response: string): XMLHttpRequest => {
+                let xhrReq = this.requests.shift();
+                xhrReq.responsetype = "text/html";
+                xhrReq.respond(403, {'Content-Type': 'text/html'}, "server error");
+                return xhrReq;
+            };
+
+            this.xhr.onCreate = (xhr) => {
+                this.requests.push(xhr);
+            };
+            (<any>global).XMLHttpRequest = this.xhr;
+            window.XMLHttpRequest = this.xhr;
+
+            this.closeIt = () => {
+                (<any>global).XMLHttpRequest = window.XMLHttpRequest = this.xhr.restore();
+                Implementation.reset();
+                close();
+            }
+        });
+    });
+
+    afterEach(function () {
+        this.closeIt();
+    });
+
+    it("No Error Case", function (done) {
+        DQ.byId("form1:button1").click();
+        expect(Implementation.requestQueue.queue.length >= 4).to.be.true;
+        for (let cnt = 1; cnt <= 5; cnt++) {
+            if(!Implementation.requestQueue.queue.length) {
+                //the last non queued element waits for another response
+                this.respond(XmlResponses.ERROR_CHAIN_RESPOND_OK(cnt));
+                break;
+            }
+            this.respond(XmlResponses.ERROR_CHAIN_RESPOND_OK(cnt))
+        }
+
+
+        expect(DQ.byId("errorCalled").innerHTML).to.eq("");
+        expect(DQ.byId("form1:out1").innerHTML).to.eq("5");
+        done();
+    })
+
+    it("must process the error chain properly", function (done) {
+        DQ.byId("form1:button1").click();
+        expect(Implementation.requestQueue.queue.length >= 4).to.be.true;
+
+        for (let cnt = 1; cnt <= 5; cnt++) {
+            if(!Implementation.requestQueue.queue.length) {
+                this.respond(XmlResponses.ERROR_CHAIN_RESPOND_OK(cnt));
+                break;
+            }
+            if (cnt == 3) {
+                //any error suffices
+                this.respond403();
+            } else {
+                this.respond(XmlResponses.ERROR_CHAIN_RESPOND_OK(cnt))
+            }
+        }
+        expect(Implementation.requestQueue.queue.length).to.eq(0);
+        expect(DQ.byId("errorCalled").innerHTML).to.eq("1");
+        expect(DQ.byId("form1:out1").innerHTML).to.eq("5");
+        done();
+    })
+});
+

package/src/main/typescript/test/xhrCore/NamespacesRequestTest.spec.ts

@@ -18,22 +18,19 @@ import {describe, it} from "mocha";
 import * as sinon from "sinon";
 import {expect} from "chai";
 import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
-import {_Es2019Array, DomQuery, DQ$, Stream} from "mona-dish";
+import {_Es2019Array, DQ$} from "mona-dish";
 import {
-    $nsp,
-    COMPLETE,
     P_AJAX,
     P_EXECUTE,
     P_AJAX_SOURCE,
     P_RENDER,
     P_VIEWSTATE,
-    P_WINDOW_ID,
-    SUCCESS
+    P_WINDOW_ID
 } from "../../impl/core/Const";
-import defaultMyFaces = StandardInits.defaultMyFaces;
-import STD_XML = StandardInits.STD_XML;
 import defaultMyFacesNamespaces = StandardInits.defaultMyFacesNamespaces;
 import {escape} from "querystring";
+import {ExtLang} from "../../impl/util/Lang";
+import ofAssoc = ExtLang.ofAssoc;
 
 declare var faces: any;
 declare var Implementation: any;
@@ -190,13 +187,13 @@ describe('Namespacing tests', function () {
             expect(!!resultsMap["render"]).to.be.false;
             expect(!!resultsMap["execute"]).to.be.false;
 
-            let hasWindowdId = Stream.ofAssoc(resultsMap).filter(data => data[0].indexOf(P_WINDOW_ID) != -1).first().isPresent();
-            let hasViewState = Stream.ofAssoc(resultsMap).filter(data => data[0].indexOf(P_VIEWSTATE) != -1).first().isPresent();
+            let hasWindowdId = ofAssoc(resultsMap).filter(data => data[0].indexOf(P_WINDOW_ID) != -1)?.[0];
+            let hasViewState = ofAssoc(resultsMap).filter(data => data[0].indexOf(P_VIEWSTATE) != -1)?.[0];
 
-            expect(hasWindowdId).to.be.false;
-            expect(hasViewState).to.be.true;
+            expect(!!hasWindowdId).to.be.false;
+            expect(!!hasViewState).to.be.true;
 
-            let viewState = Stream.ofAssoc(resultsMap).filter(data => data[0].indexOf(P_VIEWSTATE) != -1).map(item => item[1]).first().value;
+            let viewState = ofAssoc(resultsMap).filter(data => data[0].indexOf(P_VIEWSTATE) != -1).map(item => item[1])?.[0];
 
             expect(viewState).to.eq("booga");
             expect(resultsMap[NAMING_CONTAINER_PREF + P_AJAX_SOURCE]).to.eq("jd_0:input_2");