jsf.js_next_gen 4.0.1-beta.2 → 4.0.1-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.0.1-beta.2",
+  "version": "4.0.1-beta.3",
   "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",
@@ -39,16 +39,16 @@
     "replace-in-file": "^6.3.5",
     "rxjs": "^7.8.0",
     "sinon": "^15.0.1",
-    "terser-webpack-plugin": "^5.3.6",
+    "terser-webpack-plugin": "^5.3.7",
     "ts-loader": "^9.4.2",
     "ts-node": "^10.9.1",
     "typedoc": "^0.23.26",
     "typescript": "^4.9.5",
-    "webpack": "^5.75.0",
+    "webpack": "^5.76.0",
     "webpack-cli": "^5.0.1",
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "mona-dish": "0.26.0"
+    "mona-dish": "0.28.0"
   }
 }

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/src/main/typescript/api/_api.ts

@@ -277,7 +277,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, DomQuery, DQ, DQ$, Lang, LazyStream, Optional, Stream} from "mona-dish";
+import {Config, DQ, 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,11 @@ import {
     VIEW_ID,
     $faces,
     EMPTY_STR,
-    CTX_PARAM_MF_INTERNAL,
     NAMED_VIEWROOT,
-    NAMING_CONTAINER_ID, $nsp
+    NAMING_CONTAINER_ID,
+    CTX_PARAM_PPS,
+    MYFACES_OPTION_PPS,
+    $nsp
 } from "./core/Const";
 import {
     resolveDefaults,
@@ -63,6 +64,7 @@ import {
     resolveTimeout, resolveViewId, resolveViewRootId, resoveNamingContainerMapper
 } from "./xhrCore/RequestDataResolver";
 import {encodeFormData} from "./util/FileUtils";
+import {XhrQueueController} from "./util/XhrQueueController";
 
 /*
  * allowed project stages
@@ -91,6 +93,8 @@ enum BlockFilter {
     params = "params"
 }
 
+
+
 /**
  * Core Implementation
  * to distinct between api and impl
@@ -110,17 +114,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 +151,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 +188,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 +214,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 +278,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 +310,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 +344,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 +427,7 @@ export module Implementation {
             }
         } finally {
             if (clearRequestQueue) {
-                requestQueue.cleanup();
+                requestQueue.clear();
             }
         }
     }
@@ -558,7 +561,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));
     }
 
     /**
@@ -573,8 +576,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);
         }
     };
 
@@ -683,7 +686,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,
@@ -697,7 +700,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;
@@ -716,14 +719,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
@@ -765,24 +768,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));
     }
 }

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

@@ -1,4 +1,4 @@
-import {ArrayCollector, Config, DomQuery, DQ, LazyStream, Stream} from "mona-dish";
+import {Config, DomQuery, DQ} from "mona-dish";
 import {ExtDomQuery} from "./ExtDomQuery";
 import {$faces, EMPTY_STR} from "../core/Const";
 
@@ -22,27 +22,24 @@ export function encodeFormData(formData: Config,
     }
     const assocValues = formData.value;
 
-    const expandValueArrAndRename = key => Stream.of(...assocValues[key]).map(val => paramsMapper(key, val));
+    const expandValueArrAndRename = key => assocValues[key].map(val => paramsMapper(key, val));
     const isPropertyKey = key => assocValues.hasOwnProperty(key);
     const isNotFile = ([, value]) => !(value instanceof ExtDomQuery.global().File);
     const mapIntoUrlParam = keyVal => `${encodeURIComponent(keyVal[0])}=${encodeURIComponent(keyVal[1])}`;
 
-    const entries = LazyStream.of(...Object.keys(assocValues))
+    return Object.keys(assocValues)
         .filter(isPropertyKey)
         .flatMap(expandValueArrAndRename)
-        //we cannot encode file elements that is handled by multipart requests anyway
         .filter(isNotFile)
         .map(mapIntoUrlParam)
-        .collect(new ArrayCollector());
-
-    return entries.join("&")
+        .join("&");
 }
 
 /**
  * splits and decodes encoded values into strings containing of key=value
  * @param encoded encoded string
  */
-export function decodeEncodedValues(encoded: string): Stream<string[]> {
+export function decodeEncodedValues(encoded: string): string[][] {
     const filterBlanks = item => !!(item || '').replace(/\s+/g, '');
     const splitKeyValuePair = line => {
         let index = line.indexOf("=");
@@ -53,9 +50,7 @@ export function decodeEncodedValues(encoded: string): Stream<string[]> {
     };
 
     let requestParamEntries = decodeURIComponent(encoded).split(/&/gi);
-    return Stream.of(...requestParamEntries)
-        .filter(filterBlanks)
-        .map(splitKeyValuePair)
+    return requestParamEntries.filter(filterBlanks).map(splitKeyValuePair);
 }
 
 
@@ -63,19 +58,28 @@ export function decodeEncodedValues(encoded: string): Stream<string[]> {
  * gets all the input files and their corresponding file objects
  * @param dataSource
  */
-export function resolveFiles(dataSource: DQ): Stream<[string, File]> {
+export function resolveFiles(dataSource: DQ): [string, File][] {
+
+    const expandFilesArr = ([key, files]) => {
+        return [...files].map(file => [key, file]);
+    }
+    const remapFileInput = fileInput => {
+        return [fileInput.name.value || fileInput.id.value, fileInput.filesFromElem(0)];
+    }
 
-    const expandFilesArr = ([key, files]) => Stream.of(...files).map(file => [key, file]);
-    const remapFileInput = fileInput => [fileInput.name.value || fileInput.id.value, fileInput.filesFromElem(0)];
-    return dataSource
+    const files = dataSource
         .querySelectorAllDeep("input[type='file']")
-        .stream
+        .asArray;
+
+    const ret = files
         .map(remapFileInput)
         .flatMap(expandFilesArr);
+
+    return ret as any;
 }
 
 
-export function fixEmmptyParameters(keyVal: any[]): [string, any] {
+export function fixEmptyParameters(keyVal: any[]): [string, any] {
     return (keyVal.length < 3 ? [keyVal?.[0] ?? [], keyVal?.[1] ?? []] : keyVal) as [string, any];
 }
 
@@ -83,7 +87,7 @@ export function fixEmmptyParameters(keyVal: any[]): [string, any] {
  * returns the decoded viewState from parentItem
  * @param parentItem
  */
-function resolveViewState(parentItem: DomQuery): Stream<string[] | [string, File]> {
+function resolveViewState(parentItem: DomQuery): string[][] | [string, File][] {
     const viewStateStr = $faces().getViewState(parentItem.getAsElem(0).value);
 
     // we now need to decode it and then merge it into the target buf
@@ -94,11 +98,11 @@ function resolveViewState(parentItem: DomQuery): Stream<string[] | [string, File
 
 /**
  * gets all the inputs under the form parentItem
- * as stream
+ * as array
  * @param parentItem
  */
-export function getFormInputsAsStream(parentItem: DomQuery): Stream<string[] | [string, File]> {
-    const standardInputs = resolveViewState(parentItem);
+export function getFormInputsAsArr(parentItem: DomQuery): string[][] | [string, File][] {
+    const standardInputs: any = resolveViewState(parentItem);
     const fileInputs = resolveFiles(parentItem);
-    return  standardInputs.concat(fileInputs as any)
+    return standardInputs.concat(...fileInputs)
 }

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

@@ -58,13 +58,17 @@ export class HiddenInputBuilder {
         const SEP = $faces().separatorchar;
 
         let existingStates = DQ$(`[name*='${$nsp(this.name)}']`);
-        let cnt = existingStates.stream.map(state => {
+        let cnt = existingStates.asArray.map(state => {
             let ident: string = state.id.orElse("-1").value;
             ident = ident.substring(ident.lastIndexOf(SEP)+1);
             return parseInt(ident);
         })
-            .filter(item => !isNaN(item))
-            .reduce((item1, item2) => Math.max(item1, item2), -1).value;
+            .filter(item => {
+                return !isNaN(item);
+            })
+            .reduce((item1, item2) => {
+                return Math.max(item1, item2);
+            }, -1);
         //the maximum  new ident is the current max + 1
         cnt++;