jsf.js_next_gen 4.0.0 → 4.0.1-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.0.0",
+  "version": "4.0.1-alpha.0",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/faces.js",
   "scripts": {
@@ -23,7 +23,7 @@
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@types/chai": "^4.3.4",
     "@types/mocha": "^10.0.1",
-    "@types/node": "^18.14.2",
+    "@types/node": "^18.14.6",
     "@types/sinon": "^10.0.13",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
     "chai": "^4.3.7",
@@ -49,6 +49,6 @@
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "mona-dish": "^0.26.0"
+    "mona-dish": "0.25.28"
   }
 }

package/plans for 4.0.1.txt

@@ -0,0 +1,8 @@
+# Brainstorming for 4.0.1
+
+* Eliminate Streams - done, this was the biggest one
+* Reintroduce partial page submit (myfaces.pps?), while never really used - done, pps=true is reintroduced
+reducing the commit load onto execute!
+
+queue size reduction... not really needed, there never was a usecase for it
+

package/pom.xml

@@ -10,7 +10,7 @@
     </parent>
     <groupId>com.example</groupId>
     <artifactId>jsfs_js_ts</artifactId>
-    <version>4.0</version>
+    <version>0.0.1-SNAPSHOT</version>
     <name>jsfs_js_ts</name>
     <description>Demo project for Spring Boot</description>
 

package/src/main/typescript/@types/definitions/index.d.ts

@@ -50,10 +50,10 @@ declare global {
      *     <li> errorData.status : the error status message</li>
      *     <li> errorData.serverErrorName : the server error name in case of a server error</li>
      *     <li> errorData.serverErrorMessage : the server error message in case of a server error</li>
-     *     <li> errorData.source  : the issuing source element which triggered the request </li>
-     *     <li> eventData.responseCode: the response code (aka http request response code, 401 etc...) </li>
-     *     <li> eventData.responseText: the response text </li>
-     *     <li> eventData.responseXML: the response xml </li>
+     *     <li> errorData.source  : the issuing source element which triggered the requestInternal </li>
+     *     <li> eventData.responseCode: the response code (aka http requestInternal response code, 401 etc...) </li>
+     *     <li> eventData.responseText: the requestInternal response text </li>
+     *     <li> eventData.responseXML: the requestInternal response xml </li>
      * </ul>
      */
     interface IErrorData {
@@ -78,7 +78,7 @@ declare global {
     }
 
     interface Ajax {
-        request(element: Element, event?: Event, options?: Options): void;
+        request(element: Element, event?: Event, options?: Context): void;
         response(request: XMLHttpRequest, context?: Context): void;
     }
 

package/src/main/typescript/api/_api.ts

@@ -117,19 +117,19 @@ export module faces {
         /**
          * this function has to send the ajax requests
          *
-         * following request conditions must be met:
+         * following requestInternal conditions must be met:
          * <ul>
-         *  <li> the request must be sent asynchronously! </li>
-         *  <li> the request must be a POST!!! request </li>
-         *  <li> the request url must be the form action attribute </li>
-         *  <li> all requests must be queued with a client side request queue to ensure the request ordering!</li>
+         *  <li> the requestInternal must be sent asynchronously! </li>
+         *  <li> the requestInternal must be a POST!!! requestInternal </li>
+         *  <li> the requestInternal url must be the form action attribute </li>
+         *  <li> all requests must be queued with a client side requestInternal queue to ensure the requestInternal ordering!</li>
          * </ul>
          *
          * @param {String|Node} element: any dom element no matter being it html or jsf, from which the event is emitted
          * @param {EVENT} event: any javascript event supported by that object
          * @param {Map} options : map of options being pushed into the ajax cycle
          */
-        export function request(element: Element, event?: Event, options?: Options): void {
+        export function request(element: Element, event?: Event, options?: Context): void {
             Implementation.request(element, event, options)
         }
 
@@ -138,6 +138,7 @@ export module faces {
          * @param request the request object having triggered this response
          * @param context the request context
          *
+         * TODO add info on what can be in the context
          */
         export function response(request: XMLHttpRequest, context?: Context): void {
             Implementation.response(request, context);
@@ -152,10 +153,10 @@ export module faces {
          *     <li> errorData.status : the error status message</li>
          *     <li> errorData.serverErrorName : the server error name in case of a server error</li>
          *     <li> errorData.serverErrorMessage : the server error message in case of a server error</li>
-         *     <li> errorData.source  : the issuing source element which triggered the request </li>
-         *     <li> eventData.responseCode: the response code (aka http request response code, 401 etc...) </li>
-         *     <li> eventData.responseText: the request response text </li>
-         *     <li> eventData.responseXML: the request response xml </li>
+         *     <li> errorData.source  : the issuing source element which triggered the requestInternal </li>
+         *     <li> eventData.responseCode: the response code (aka http requestInternal response code, 401 etc...) </li>
+         *     <li> eventData.responseText: the requestInternal response text </li>
+         *     <li> eventData.responseXML: the requestInternal response xml </li>
          * </ul>
          *
          * @param errorFunc error handler must be of the format <i>function errorListener(&lt;errorData&gt;)</i>
@@ -188,7 +189,7 @@ export module faces {
          * @param funcs ... arbitrary array of functions or strings
          * @returns true if the chain has succeeded false otherwise
          */
-        export function chain(source: HTMLElement | string, event: Event | null, ...funcs: Array<Function | string>): boolean {
+        export function chain(source, event, ...funcs: Array<Function | string>): boolean {
             return Implementation.chain(source, event, ...(funcs as EvalFuncs));
         }
     }
@@ -277,7 +278,7 @@ export module myfaces {
      *
      * @param executionFunc the function to be executed upon ready
      */
-    export function onOnDomReady(executionFunc: () => void) {
+    export function onDomReady(executionFunc: () => void) {
         if(document.readyState !== "complete") {
             onReadyChain.push(executionFunc);
             if(!readyStateListener) {

package/src/main/typescript/impl/AjaxImpl.ts

@@ -17,8 +17,7 @@
 import {IListener} from "./util/IListener";
 import {Response} from "./xhrCore/Response";
 import {XhrRequest} from "./xhrCore/XhrRequest";
-import {AsynchronousQueue} from "./util/AsyncQueue";
-import {AssocArrayCollector, Config, DQ, Lang, LazyStream, Optional, Stream} from "mona-dish";
+import {Config, DQ, Lang, Optional} from "mona-dish";
 import {Assertions} from "./util/Assertions";
 import {ExtConfig, ExtDomQuery} from "./util/ExtDomQuery";
 import {ErrorData} from "./xhrCore/ErrorData";
@@ -41,7 +40,7 @@ import {
     P_CLIENT_WINDOW,
     P_EVT,
     P_EXECUTE,
-    P_PARTIAL_SOURCE,
+    P_AJAX_SOURCE,
     P_RENDER,
     P_RESET_VALUES,
     P_WINDOW_ID,
@@ -52,9 +51,8 @@ import {
     VIEW_ID,
     $faces,
     EMPTY_STR,
-    CTX_PARAM_MF_INTERNAL,
     NAMED_VIEWROOT,
-    NAMING_CONTAINER_ID
+    NAMING_CONTAINER_ID, CTX_PARAM_PPS, MYFACES_OPTION_PPS
 } from "./core/Const";
 import {
     resolveDefaults,
@@ -63,6 +61,7 @@ import {
     resolveTimeout, resolveViewId, resolveViewRootId, resoveNamingContainerMapper
 } from "./xhrCore/RequestDataResolver";
 import {encodeFormData} from "./util/FileUtils";
+import {XhrQueueController} from "./util/XhrQueueController";
 
 /*
  * allowed project stages
@@ -91,6 +90,8 @@ enum BlockFilter {
     params = "params"
 }
 
+
+
 /**
  * Core Implementation
  * to distinct between api and impl
@@ -110,17 +111,7 @@ export module Implementation {
  it provides following
 
  a) Monad like structures for querying because this keeps the code denser and adds abstractions
- that always was the strong point of jquery and it still is better in this regard than what ecmascript provides
-
- b) Streams and lazy streams like java has, a pull stream construct, ecmascript does not have anything like it.
- (it has array filters and maps, but ES2015 does not support flatMap)
- Another option would have been rxjs but that would have introduced a code dependency and probably more code. We might
- move to RXJS if the need arises, however. But for now I would rather stick with my small self grown library which works
- quite well and where I can patch quickly (I have used it in several industrial projects, so it works well
- and is heavily fortified by unit tests (140 testcases as time of writing this))
- The long term plan is to eliminate the Stream usage as soon as we can move up to ES2019 (adding the missing
- functions as shims, is a no go, because we are a library, and absolutey do not Shim anything which can leak
- into the global namespace!)
+ that always was the strong point of jQuery, and it still is better in this regard than what ecmascript provides
 
  c) A neutral json like configuration which allows assignments of arbitrary values with reduce code which then can be
  transformed into different data representations
@@ -157,12 +148,14 @@ export module Implementation {
     import getMessage = ExtLang.getMessage;
     import getGlobalConfig = ExtLang.getGlobalConfig;
     import assert = Assertions.assert;
+    import ofAssoc = ExtLang.ofAssoc;
+    import collectAssoc = ExtLang.collectAssoc;
 
     let projectStage: string = null;
     let separator: string = null;
     let eventQueue = [];
     let errorQueue = [];
-    export let requestQueue: AsynchronousQueue<XhrRequest> = null;
+    export let requestQueue: XhrQueueController<XhrRequest> = null;
     /*error reporting threshold*/
     let threshold = "ERROR";
 
@@ -192,7 +185,7 @@ export module Implementation {
     /**
      * @return the project stage also emitted by the server:
      * it cannot be cached and must be delivered over the server
-     * The value for it comes from the request parameter of the faces.js script called "stage".
+     * The value for it comes from the requestInternal parameter of the faces.js script called "stage".
      */
     export function getProjectStage(): string | null {
         return resolveGlobalConfig()?.projectStage ??
@@ -218,17 +211,21 @@ export module Implementation {
      * @param event
      * @param funcs
      */
-    export function chain(source: HTMLElement | string, event: Event | null, ...funcs: EvalFuncs): boolean {
-        // we can use our lazy stream each functionality to run our chain here..
+    export function chain(source: any, event: Event, ...funcs: EvalFuncs): boolean {
+        // we can use our lazy stream each functionality to run our chain here.
         // by passing a boolean as return value into the onElem call
         // we can stop early at the first false, just like the spec requests
 
-        return LazyStream.of(...funcs)
-            .map(func => resolveAndExecute(source, event, func))
-            // we use the return false == stop as an early stop, onElem stops at the first false
-            .onElem((opResult: boolean) => opResult)
-            //last ensures we run until the first false is returned
-            .last().value;
+        let ret;
+        funcs.every(func => {
+            let returnVal = resolveAndExecute(source, event, func);
+            if(returnVal !== false) {
+                ret = returnVal;
+            }
+            return returnVal !== false;
+        });
+        return ret;
+
     }
 
     /**
@@ -278,7 +275,7 @@ export module Implementation {
 
         requestCtx.assignIf(!!windowId, P_WINDOW_ID).value = windowId;
 
-        // old non spec behavior will be removed after it is clear whether the removal breaks any code
+        // old non - spec behavior will be removed after it is clear whether the removal breaks any code
         requestCtx.assign(CTX_PARAM_REQ_PASS_THR).value = extractLegacyParams(options.value);
 
         // spec conform behavior, all passthrough params must be under "passthrough
@@ -310,14 +307,14 @@ export module Implementation {
         requestCtx.assign(ON_ERROR).value = options.value?.onerror;
 
         /**
-         * lets drag the myfaces config params also in
+         * Fetch the myfaces config params
          */
         requestCtx.assign(MYFACES).value = options.value?.myfaces;
 
         /**
          * binding contract the jakarta.faces.source must be set
          */
-        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, P_PARTIAL_SOURCE).value = elementId;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, P_AJAX_SOURCE).value = elementId;
 
         /**
          * jakarta.faces.partial.ajax must be set to true
@@ -344,6 +341,9 @@ export module Implementation {
         // won't hurt but for the sake of compatibility we are going to add it
         requestCtx.assign(CTX_PARAM_REQ_PASS_THR, formId).value = formId;
         internalCtx.assign(CTX_PARAM_SRC_CTL_ID).value = elementId;
+        // reintroduction of PPS as per myfaces 2.3 (myfaces.pps = true, only the executes are submitted)
+        internalCtx.assign(CTX_PARAM_PPS).value = extractMyFacesParams(options.value)?.[MYFACES_OPTION_PPS] ?? false;
+
 
         assignClientWindowId(form, requestCtx);
         assignExecute(options, requestCtx, form, elementId);
@@ -424,7 +424,7 @@ export module Implementation {
             }
         } finally {
             if (clearRequestQueue) {
-                requestQueue.cleanup();
+                requestQueue.clear();
             }
         }
     }
@@ -503,7 +503,8 @@ export module Implementation {
          * or non-existent. If they exist all of them must be the same
          */
 
-        let formWindowId: Optional<string> = searchRoot.stream.map(getValue).reduce(differenceCheck, INIT);
+        let formWindowId: Optional<string> = Optional.fromNullable(searchRoot.asArray
+            .map<string>(getValue).reduce(differenceCheck, INIT));
 
 
         //if the resulting window id is set on altered then we have an unresolvable problem
@@ -541,7 +542,7 @@ export module Implementation {
         let formElements = element.deepElements.encodeFormElement()
 
         // encode them! (file inputs are handled differently and are not part of the viewstate)
-        return encodeFormData(formElements, resoveNamingContainerMapper(dummyContext));
+        return encodeFormData(new ExtConfig(formElements), resoveNamingContainerMapper(dummyContext));
     }
 
     /**
@@ -556,8 +557,8 @@ export module Implementation {
          * adds a new request to our queue for further processing
          */
         addRequestToQueue: function (elem: DQ, form: DQ, reqCtx: ExtConfig, respPassThr: Config, delay = 0, timeout = 0) {
-            requestQueue = requestQueue ?? new AsynchronousQueue<XhrRequest>();
-            requestQueue.enqueue(new XhrRequest(elem, form, reqCtx, respPassThr, [], timeout), delay);
+            requestQueue = requestQueue ?? new XhrQueueController<XhrRequest>();
+            requestQueue.enqueue(new XhrRequest(reqCtx, respPassThr, timeout), delay);
         }
     };
 
@@ -666,7 +667,7 @@ export module Implementation {
          * can deal with them either prefixed ir not
          * also resolves the absolute id case (it was assumed the server does this, but
          * apparently the RI does not, so we have to follow the RI behavior here)
-         * @param componentIdToTransform the componentId which needs post processing
+         * @param componentIdToTransform the componentId which needs post-processing
          */
         const remapNamingContainer = componentIdToTransform => {
             // pattern :<anything> must be prepended by viewRoot if there is one,
@@ -680,7 +681,7 @@ export module Implementation {
             const hasLeadingSep = componentIdToTransform.indexOf(SEP) === 0;
             const isAbsolutSearchExpr = hasLeadingSep || (rootNamingContainerId.length
                 && componentIdToTransform.indexOf(rootNamingContainerPrefix) == 0);
-            let finalIdentifier = "";
+            let finalIdentifier: string;
             if (isAbsolutSearchExpr) {
                 //we cut off the leading sep if there is one
                 componentIdToTransform = hasLeadingSep ? componentIdToTransform.substring(1) : componentIdToTransform;
@@ -699,14 +700,14 @@ export module Implementation {
                     [rootNamingContainerPrefix, componentIdToTransform].join(EMPTY_STR) :
                     [nearestNamingContainerPrefix,  componentIdToTransform].join(EMPTY_STR);
             }
-            // We need to double check because we have scenarios where we have a naming container
+            // We need to double-check because we have scenarios where we have a naming container
             // and no prepend (aka tobago testcase "must handle ':' in IDs properly", scenario 3,
             // in this case we return the component id, and be happy
             // we can roll a dom check here
             return (!!document.getElementById(finalIdentifier)) ? finalIdentifier : componentIdToTransform;
         };
 
-        // in this case we do not use lazy stream because it wont bring any code reduction
+        // in this case we do not use lazy stream because it won´t bring any code reduction
         // or speedup
         for (let cnt = 0; cnt < iterValues.length; cnt++) {
             //avoid doubles
@@ -748,24 +749,37 @@ export module Implementation {
      * the values required for params-through are processed in the ajax request
      *
      * Note this is a bug carried over from the old implementation
-     * the spec conform behavior is to use params for passthrough values
+     * the spec conform behavior is to use params for pass - through values
      * this will be removed soon, after it is cleared up whether removing
      * it breaks any legacy code
      *
      * @param {Context} mappedOpts the options to be filtered
-     * @deprecated
      */
-    function extractLegacyParams(mappedOpts: Options): Context {
+    function extractLegacyParams(mappedOpts: Options): {[key: string]: any} {
+        //we now can use the full code reduction given by our stream api
+        //to filter
+        return ofAssoc(mappedOpts)
+            .filter((item => !(item[0] in BlockFilter)))
+            .reduce(collectAssoc, {});
+    }
+
+    /**
+     * extracts the myfaces config parameters which provide extra functionality
+     * on top of JSF
+     * @param mappedOpts
+     * @private
+     */
+    function extractMyFacesParams(mappedOpts: Options): {[key: string]: any} {
         //we now can use the full code reduction given by our stream api
         //to filter
-        return Stream.ofAssoc(mappedOpts)
-            .filter(item => !(item[0] in BlockFilter))
-            .collect(new AssocArrayCollector());
+        return ofAssoc(mappedOpts)
+            .filter((item => (item[0] == "myfaces")))
+            .reduce(collectAssoc, {})?.[MYFACES];
     }
 
     function remapArrayToAssocArr(arrayedParams: [[string, any]] | {[key: string]: any}): {[key: string]: any} {
         if(Array.isArray(arrayedParams)) {
-            return Stream.of(... arrayedParams).collect(new AssocArrayCollector());
+            return arrayedParams.reduce(collectAssoc, {} as any);
         }
         return arrayedParams;
     }

package/src/main/typescript/impl/core/Const.ts

@@ -21,8 +21,8 @@
 export const XML_ATTR_NAMED_VIEWROOT = "namedViewRoot";
 export const NAMED_VIEWROOT = "namedViewRoot";
 
-export const P_PARTIAL_SOURCE = "jakarta.faces.source";
-export const NAMING_CONTAINER_ID = "myfaces.partialId";
+export const P_AJAX_SOURCE = "jakarta.faces.source";
+export const NAMING_CONTAINER_ID = "myfaces.NamingContainerId";
 
 export const VIEW_ID = "myfaces.viewId";
 export const P_VIEWSTATE = "jakarta.faces.ViewState";
@@ -108,6 +108,7 @@ export const CTX_PARAM_MF_INTERNAL = "myfaces.internal";
 export const CTX_PARAM_SRC_FRM_ID = "myfaces.source.formId";
 export const CTX_PARAM_SRC_CTL_ID = "myfaces.source.controlId";
 export const CTX_PARAM_REQ_PASS_THR = "myfaces.request.passThrough";
+export const CTX_PARAM_PPS = "myfaces.request.pps";
 
 export const CONTENT_TYPE = "Content-Type";
 export const HEAD_FACES_REQ = "Faces-Request";
@@ -141,6 +142,8 @@ export const PHASE_PROCESS_RESPONSE = "processResponse";
 
 export const ERR_NO_PARTIAL_RESPONSE = "Partial response not set";
 
+export const MYFACES_OPTION_PPS = "pps";
+
 export const ATTR_URL = "url";
 export const ATTR_NAME = "name";
 export const ATTR_VALUE = "value";

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

@@ -26,7 +26,7 @@
  * from the implementation side it is mostly registering callbacks
  * and calling them at the appropriate time.
  */
-export interface AsyncRunnable<T> {
+export interface IAsyncRunnable<T> {
     /**
      * starts the runnable
      */
@@ -45,9 +45,9 @@ export interface AsyncRunnable<T> {
      * and then triggers all the registered then functions
      * when it is complete
      *
-     * @param func
+     * @param func the then functor
      */
-    then(func: (data: any) => any): AsyncRunnable<T>;
+    then(func: (data: any) => any): IAsyncRunnable<T>;
 
     /**
      * callback for catch functionality
@@ -59,7 +59,7 @@ export interface AsyncRunnable<T> {
      *
      * @param func
      */
-    catch(func: (data: any) => any): AsyncRunnable<T>;
+    catch(func: (data: any) => any): IAsyncRunnable<T>;
 
 
     /**
@@ -68,5 +68,80 @@ export interface AsyncRunnable<T> {
      * and once the finally time for the promise has
      * come the finally functions must be performed
      */
-    finally(func: () => void): AsyncRunnable<T>;
-}
+    finally(func: () => void): IAsyncRunnable<T>;
+}
+
+
+/**
+ * pretty much the same as cancellable Promise, but given
+ * we do not have that on browser level yet this is sort
+ * of a non - intrusive Shim!
+ */
+export abstract class AsyncRunnable<T> implements IAsyncRunnable<T>{
+    /**
+     * helper support so that we do not have to drag in Promise shims
+     */
+    private catchFunctions: Array<Function> = [];
+    private thenFunctions: Array<Function> = [];
+
+    /**
+     * cancel the run of the runnable (which then depending on the implementation
+     * either triggers indirectly resolve or reject)
+     */
+    abstract cancel(): void;
+
+    /**
+     * extended functionality start to trigger the runnable
+     */
+    abstract start(): void;
+
+    /**
+     * resolve handler function which calls the then chain
+     * and after that finally
+     * @param data
+     */
+    resolve(data: any) {
+        this.thenFunctions.reduce((inputVal: any, thenFunc: any) => {
+            return thenFunc(inputVal);
+        }, data)
+    }
+
+    /**
+     * reject handler function which triggers the catch chain
+     * @param data
+     */
+    reject(data: any) {
+        this.catchFunctions.reduce((inputVal: any, catchFunc: any) => {
+            return catchFunc(inputVal);
+        }, data);
+    }
+
+    /**
+     * register a catch functor
+     * @param func the functor for the catch monad
+     */
+    catch(func: (data: any) => any): IAsyncRunnable<T> {
+        this.catchFunctions.push(func);
+        return this;
+    }
+
+    /**
+     * registers a finally functor
+     * @param func the functor for the finally handling chanin
+     */
+    finally(func: () => void): IAsyncRunnable<T> {
+        // no ie11 support we probably are going to revert to shims for that one
+        this.catchFunctions.push(func);
+        this.thenFunctions.push(func);
+        return this;
+    }
+
+    /**
+     * @param func then functor similar to promise
+     */
+    then(func: (data: any) => any): IAsyncRunnable<T> {
+        this.thenFunctions.push(func);
+        return this;
+    }
+}
+

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Config, IValueHolder, Optional, DomQuery, DQ, Stream, ArrayCollector} from "mona-dish";
+import {Config, IValueHolder, Optional, DomQuery, DQ} from "mona-dish";
 import {$nsp, P_WINDOW_ID} from "../core/Const";
 
 
@@ -120,12 +120,10 @@ export class ExtDomQuery extends DQ {
         }
         // fallback if the currentScript method fails, we just search the jsf tags for nonce, this is
         // the last possibility
-        let nonceScript = DQ
-            .querySelectorAll("script[src], link[src]")
-            .lazyStream
+        let nonceScript = Optional.fromNullable(DQ
+            .querySelectorAll("script[src], link[src]").asArray
             .filter((item) => this.extractNonce(item)  && item.attr(ATTR_SRC) != null)
-            .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
-            .first();
+            .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))?.[0]);
 
         if (nonceScript.isPresent()) {
             return this.extractNonce(nonceScript.value);
@@ -144,13 +142,13 @@ export class ExtDomQuery extends DQ {
      */
     searchJsfJsFor(regExp: RegExp): Optional<string> {
         //perfect application for lazy stream
-        return DQ.querySelectorAll("script[src], link[src]").lazyStream
+        return Optional.fromNullable(DQ.querySelectorAll("script[src], link[src]").asArray
             .filter(item => IS_FACES_SOURCE(item.attr(ATTR_SRC).value))
             .map(item => item.attr(ATTR_SRC).value.match(regExp))
             .filter(item => item != null && item.length > 1)
             .map((result: string[]) => {
                 return decodeURIComponent(result[1]);
-            }).first();
+            })?.[0]);
     }
 
     globalEval(code: string, nonce ?: string): DQ {
@@ -332,6 +330,6 @@ export class ExtConfig extends  Config {
         if(!this.$nspEnabled) {
             return accessPath;
         }
-        return Stream.of(...accessPath).map(key => $nsp(key)).collect(new ArrayCollector());
+        return [...accessPath].map(key => $nsp(key));
     }
 }