jsf.js_next_gen 4.0.0-RC.2 → 4.0.0-RC.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.0.0-RC.2",
+  "version": "4.0.0-RC.21",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/faces.js",
   "scripts": {
@@ -21,33 +21,33 @@
   "license": "Apache-2.0",
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
-    "@types/chai": "^4.3.3",
-    "@types/mocha": "^10.0.0",
-    "@types/node": "^18.11.9",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^18.11.18",
     "@types/sinon": "^10.0.13",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
-    "chai": "^4.3.6",
+    "chai": "^4.3.7",
     "compression-webpack-plugin": "^10.0.0",
     "html-webpack-plugin": "^5.5.0",
     "http-server": "^14.1.1",
-    "jsdom": "^20.0.2",
+    "jsdom": "^21.0.0",
     "jsdom-global": "^3.0.2",
-    "mocha": "^10.1.0",
-    "npm-check-updates": "^16.3.16",
+    "mocha": "^10.2.0",
+    "npm-check-updates": "^16.6.2",
     "nyc": "^15.1.0",
     "replace-in-file": "^6.3.5",
-    "rxjs": "^7.5.7",
-    "sinon": "^14.0.1",
+    "rxjs": "^7.8.0",
+    "sinon": "^15.0.1",
     "terser-webpack-plugin": "^5.3.6",
-    "ts-loader": "^9.4.1",
+    "ts-loader": "^9.4.2",
     "ts-node": "^10.9.1",
-    "typedoc": "^0.23.20",
-    "typescript": "^4.8.4",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0",
+    "typedoc": "^0.23.24",
+    "typescript": "^4.9.4",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
     "webpack-dev-server": "^4.11.1"
   },
   "dependencies": {
-    "mona-dish": "0.23.5"
+    "mona-dish": "^0.24.3"
   }
 }

package/src/main/test.xml

@@ -0,0 +1,23 @@
+<partial-response id="viewroot_1">
+    <changes>
+        <update id="panel2"><![CDATA[
+            <div id="panel2">
+            after update
+                <form id="form2" name="form2" method="post" action="booga2"
+                      ><a href="#" id="form2:link" name="form2:link"></a>
+                      <input type="hidden" name="form2_SUBMIT" value="1"/></form>
+            </div>
+            ]]>
+        </update>
+        <update id="panel3"><![CDATA[
+            <div id="panel3">
+            after update
+                <form id="form3" name="form3" method="post" action="booga3"
+                      ><a href="#"  id="form3:link" name="form3:link"></a>
+                </form>
+            </div>
+            ]]>
+        </update>
+        <update id="j_id__v_0:jakarta.faces.ViewState:1"><![CDATA[booga_after_update]]></update>
+    </changes>
+</partial-response>

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

@@ -23,9 +23,24 @@
 declare global {
 
     type Consumer<T> = (s?: T) => void;
+    type Tuple<V,K> = [V, K];
+    type Tuples<V,K> = [Tuple<V, K>];
     type AssocArr<T> = { [key: string]: T };
     type EvalFuncs = Array<Function | string>;
-    type Options = { [key: string]: string | Function | { [key: string]: string | Function } };
+
+
+    type Options = {
+        render ?: string,
+        execute ?: string,          //space separated list of client ids
+        onevent ?: Function,        // event handler callback
+        onerror ?: Function,        // error handler callback
+        params ?: AssocArr<any>,    // passthrough params
+        delay ?: number,            // delay in milliseconds
+        resetValues ?: boolean,     // if set to true jakarta.faces.partial.resetValues is sent
+        /* @deprecated non-spec conform fallback behavior that anything can be passed and is used as passthrough */
+        [key: string]: any
+    }
+
     type Context = AssocArr<any>;
     type ElemDef = Element | string;
 
@@ -106,7 +121,7 @@ declare global {
     interface OAM {
         clearHiddenInput(formName: string, name: string): void;
         setHiddenInput(formName: string, name: string, value: string): void;
-        submitForm(formName: string, linkId: string, target: string, params: { [key: string]: any }): boolean;
+        submitForm(formName: string, linkId?: string |null, target?: string | null, params?: AssocArr<any> |Tuples<string, any> | null): boolean;
     }
 
     interface MyFacesAPI {
@@ -119,6 +134,8 @@ declare global {
         };
     }
 
+
+
     /*
      * Global namespaces type definitions
      */

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

@@ -16,7 +16,7 @@
 import {Implementation} from "../impl/AjaxImpl";
 import {PushImpl} from "../impl/PushImpl";
 import {oam as _oam} from "../myfaces/OamSubmit";
-import {$nsp, CTX_PARAM_EXECUTE, CTX_PARAM_RENDER, P_BEHAVIOR_EVENT} from "../impl/core/Const";
+import {$nsp, CTX_OPTIONS_EXECUTE, CTX_OPTIONS_PARAMS, CTX_PARAM_RENDER, P_BEHAVIOR_EVENT} from "../impl/core/Const";
 import {ErrorData} from "../impl/xhrCore/ErrorData";
 import {EventData} from "../impl/xhrCore/EventData";
 
@@ -252,12 +252,13 @@ export module myfaces {
      * @param render
      * @param options
      */
-    export function ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: Context = {}): void {
+    export function ab(source: Element, event: Event, eventName: string, execute: string, render: string, options: Options = {}): void {
         if (eventName) {
-           options[$nsp(P_BEHAVIOR_EVENT)] = eventName;
+           options[CTX_OPTIONS_PARAMS] = options?.[CTX_OPTIONS_PARAMS] ?? {};
+           options[CTX_OPTIONS_PARAMS][$nsp(P_BEHAVIOR_EVENT)] = eventName;
         }
         if (execute) {
-            options[CTX_PARAM_EXECUTE] = execute;
+            options[CTX_OPTIONS_EXECUTE] = execute;
         }
         if (render) {
             options[CTX_PARAM_RENDER] = render;

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

@@ -21,17 +21,16 @@ import {AsynchronousQueue} from "./util/AsyncQueue";
 import {AssocArrayCollector, Config, DQ, Lang, LazyStream, Optional, Stream} from "mona-dish";
 import {Assertions} from "./util/Assertions";
 import {XhrFormData} from "./xhrCore/XhrFormData";
-import {ExtDomQuery} from "./util/ExtDomQuery";
+import {ExtConfig, ExtDomQuery} from "./util/ExtDomQuery";
 import {ErrorData} from "./xhrCore/ErrorData";
 import {EventData} from "./xhrCore/EventData";
 import {ExtLang} from "./util/Lang";
 
 import {
-    CTX_PARAM_EXECUTE,
-    CTX_PARAM_PASS_THR,
+    CTX_OPTIONS_EXECUTE,
+    CTX_PARAM_REQ_PASS_THR,
     CTX_PARAM_SRC_CTL_ID,
     CTX_PARAM_SRC_FRM_ID,
-    CTX_PARAM_TR_TYPE,
     IDENT_ALL,
     IDENT_FORM,
     IDENT_NONE,
@@ -48,15 +47,14 @@ import {
     P_RESET_VALUES,
     P_WINDOW_ID,
     CTX_PARAM_RENDER,
-    REQ_TYPE_POST,
     SOURCE,
-    TAG_FORM
+    HTML_TAG_FORM, CTX_OPTIONS_PARAMS, VIEW_ID, $faces, EMPTY_STR
 } from "./core/Const";
 import {
     resolveDefaults,
     resolveDelay,
     resolveForm,
-    resolveTimeout
+    resolveTimeout, resolveViewId
 } from "./xhrCore/RequestDataResolver";
 
 /*
@@ -81,7 +79,9 @@ enum BlockFilter {
     myfaces = "myfaces",
     delay = "delay",
     timeout = "timeout",
-    windowId = "windowId"
+    resetValues = "resetValues",
+    windowId = "windowId",
+    params = "params"
 }
 
 /**
@@ -241,15 +241,14 @@ export module Implementation {
     export function request(el: ElemDef, event?: Event, opts ?: Options) {
 
         const {
-            resolvedEvent,
             options,
             elem,
             elementId,
-            requestCtx,
-            internalCtx,
             windowId,
             isResetValues
         } = resolveDefaults(event, opts, el);
+        const requestCtx = new ExtConfig({});
+        const internalCtx = new ExtConfig({});
 
         Assertions.assertRequestIntegrity(options, elem);
 
@@ -260,15 +259,28 @@ export module Implementation {
          * so that people can use dummy forms and work
          * with detached objects
          */
-        const form: DQ = resolveForm(requestCtx, elem, resolvedEvent);
+        const form: DQ = resolveForm(elem, event);
+        const viewId: string = resolveViewId(form);
         const formId = form.id.value;
         const delay: number = resolveDelay(options);
         const timeout: number = resolveTimeout(options);
 
         requestCtx.assignIf(!!windowId, P_WINDOW_ID).value = windowId;
 
-        requestCtx.assign(CTX_PARAM_PASS_THR).value = filterPassThroughValues(options.value);
-        requestCtx.assignIf(!!resolvedEvent, CTX_PARAM_PASS_THR, P_EVT).value = resolvedEvent?.type;
+        // 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
+        const params = remapArrayToAssocArr(options.getIf(CTX_OPTIONS_PARAMS).orElse({}).value);
+        //we turn off the remapping for the param merge, because we do not want to have
+        //any namespacing to be remapped
+
+        let ctxPassthrough = requestCtx.getIf(CTX_PARAM_REQ_PASS_THR) as ExtConfig;
+        ctxPassthrough.$nspEnabled = false;
+        ctxPassthrough.shallowMerge(new Config(params), true);
+        //now we turn it on again
+        ctxPassthrough.$nspEnabled = true;
+        requestCtx.assignIf(!!event, CTX_PARAM_REQ_PASS_THR, P_EVT).value = event?.type;
 
         /**
          * ajax pass through context with the source
@@ -276,6 +288,8 @@ export module Implementation {
          */
         requestCtx.assign(SOURCE).value = elementId;
 
+        requestCtx.assign(VIEW_ID).value = viewId;
+
         /**
          * on resolvedEvent and onError...
          * those values will be traversed later on
@@ -292,12 +306,12 @@ export module Implementation {
         /**
          * binding contract the jakarta.faces.source must be set
          */
-        requestCtx.assign(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value = elementId;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, P_PARTIAL_SOURCE).value = elementId;
 
         /**
          * jakarta.faces.partial.ajax must be set to true
          */
-        requestCtx.assign(CTX_PARAM_PASS_THR, P_AJAX).value = true;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, P_AJAX).value = true;
 
         /**
          * if resetValues is set to true
@@ -306,7 +320,7 @@ export module Implementation {
          * the value has to be explicitly true, according to
          * the specs jsdoc
          */
-        requestCtx.assignIf(isResetValues, CTX_PARAM_PASS_THR, P_RESET_VALUES).value = true;
+        requestCtx.assignIf(isResetValues, CTX_PARAM_REQ_PASS_THR, P_RESET_VALUES).value = true;
 
         // additional meta information to speed things up, note internal non jsf
         // pass through options are stored under _mfInternal in the context
@@ -317,9 +331,8 @@ export module Implementation {
         // mojarra under blackbox conditions.
         // I assume it does the same as our formId_submit=1 so leaving it out
         // won't hurt but for the sake of compatibility we are going to add it
-        requestCtx.assign(CTX_PARAM_PASS_THR, formId).value = formId;
+        requestCtx.assign(CTX_PARAM_REQ_PASS_THR, formId).value = formId;
         internalCtx.assign(CTX_PARAM_SRC_CTL_ID).value = elementId;
-        internalCtx.assign(CTX_PARAM_TR_TYPE).value = REQ_TYPE_POST;
 
         assignClientWindowId(form, requestCtx);
         assignExecute(options, requestCtx, form, elementId);
@@ -505,7 +518,7 @@ export module Implementation {
          */
 
         let element: DQ = DQ.byId(form, true);
-        if (!element.isTag(TAG_FORM)) {
+        if (!element.isTag(HTML_TAG_FORM)) {
             throw new Error(getMessage("ERR_VIEWSTATE"));
         }
 
@@ -524,7 +537,7 @@ export module Implementation {
          *
          * adds a new request to our queue for further processing
          */
-        addRequestToQueue: function (elem: DQ, form: DQ, reqCtx: Config, respPassThr: Config, delay = 0, timeout = 0) {
+        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);
         }
@@ -546,7 +559,7 @@ export module Implementation {
      */
     function assignRender(requestOptions: Config, targetContext: Config, issuingForm: DQ, sourceElementId: string) {
         if (requestOptions.getIf(CTX_PARAM_RENDER).isPresent()) {
-            remapDefaultConstants(targetContext.getIf(CTX_PARAM_PASS_THR).get({}), P_RENDER, <string>requestOptions.getIf(CTX_PARAM_RENDER).value, issuingForm, <any>sourceElementId);
+            remapDefaultConstants(targetContext.getIf(CTX_PARAM_REQ_PASS_THR).get({}), P_RENDER, <string>requestOptions.getIf(CTX_PARAM_RENDER).value, issuingForm, <any>sourceElementId, targetContext.getIf(VIEW_ID).value);
         }
     }
 
@@ -564,15 +577,15 @@ export module Implementation {
      */
     function assignExecute(requestOptions: Config, targetContext: Config, issuingForm: DQ, sourceElementId: string) {
 
-        if (requestOptions.getIf(CTX_PARAM_EXECUTE).isPresent()) {
+        if (requestOptions.getIf(CTX_OPTIONS_EXECUTE).isPresent()) {
             /*the options must be a blank delimited list of strings*/
             /*compliance with Mojarra which automatically adds @this to an execute
              * the spec rev 2.0a however states, if none is issued nothing at all should be sent down
              */
-            requestOptions.assign(CTX_PARAM_EXECUTE).value = [requestOptions.getIf(CTX_PARAM_EXECUTE).value, IDENT_THIS].join(" ");
-            remapDefaultConstants(targetContext.getIf(CTX_PARAM_PASS_THR).get({}), P_EXECUTE, <string>requestOptions.getIf(CTX_PARAM_EXECUTE).value, issuingForm, <any>sourceElementId);
+            requestOptions.assign(CTX_OPTIONS_EXECUTE).value = [requestOptions.getIf(CTX_OPTIONS_EXECUTE).value, IDENT_THIS].join(" ");
+            remapDefaultConstants(targetContext.getIf(CTX_PARAM_REQ_PASS_THR).get({}), P_EXECUTE, <string>requestOptions.getIf(CTX_OPTIONS_EXECUTE).value, issuingForm, <any>sourceElementId, targetContext.getIf(VIEW_ID).value);
         } else {
-            targetContext.assign(CTX_PARAM_PASS_THR, P_EXECUTE).value = sourceElementId;
+            targetContext.assign(CTX_PARAM_REQ_PASS_THR, P_EXECUTE).value = sourceElementId;
         }
     }
 
@@ -584,16 +597,16 @@ export module Implementation {
      */
     function assignClientWindowId(form: DQ, targetContext: Config) {
 
-        let clientWindow = (window?.faces ?? window?.jsf).getClientWindow(form.getAsElem(0).value);
+        let clientWindow = $faces().getClientWindow(form.getAsElem(0).value);
         if (clientWindow) {
-            targetContext.assign(CTX_PARAM_PASS_THR, P_CLIENT_WINDOW).value = clientWindow;
+            targetContext.assign(CTX_PARAM_REQ_PASS_THR, P_CLIENT_WINDOW).value = clientWindow;
         }
     }
 
     /**
      * transforms the user values to the expected one
      * with the proper none all form and this handling
-     * (note we also could use a simple string replace but then
+     * (note we also could use a simple string replace, but then
      * we would have had double entries under some circumstances)
      *
      * there are several standardized constants which need a special treatment
@@ -604,14 +617,60 @@ export module Implementation {
      * @param userValues the passed user values (aka input string which needs to be transformed)
      * @param issuingForm the form where the issuing element originates
      * @param issuingElementId the issuing element
+     * @param rootNamingContainerId the naming container id ("" default if none is given)
      */
-    function remapDefaultConstants(targetConfig: Config, targetKey: string, userValues: string, issuingForm: DQ, issuingElementId: string): Config {
+    function remapDefaultConstants(targetConfig: Config, targetKey: string, userValues: string, issuingForm: DQ, issuingElementId: string, rootNamingContainerId: string = ""): Config {
         //a cleaner implementation of the transform list method
-
+        const SEP = $faces().separatorchar;
         let iterValues: string[] = (userValues) ? trim(userValues).split(/\s+/gi) : [];
         let ret = [];
         let processed: {[key: string]: boolean} = {};
 
+        /**
+         * remaps the client ids for the portlet case so that the server
+         * 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
+         */
+        const remapNamingContainer = componentIdToTransform => {
+            // pattern :<anything> must be prepended by viewRoot if there is one,
+            // otherwise we are in a not namespaced then only the id has to match
+            const rootNamingContainerPrefix = (rootNamingContainerId.length) ? rootNamingContainerId+SEP : EMPTY_STR;
+            let formClientId = issuingForm.id.value;
+            // nearest parent naming container relative to the form
+            const nearestNamingContainer = formClientId.substring(0, formClientId.lastIndexOf(SEP));
+            const nearestNamingContainerPrefix = (nearestNamingContainer.length) ? nearestNamingContainer + SEP : EMPTY_STR;
+            // Absolute search expressions, always start with SEP or the name of the root naming container
+            const hasLeadingSep = componentIdToTransform.indexOf(SEP) === 0;
+            const isAbsolutSearchExpr = hasLeadingSep || (rootNamingContainerId.length
+                && componentIdToTransform.indexOf(rootNamingContainerPrefix) == 0);
+            let finalIdentifier = "";
+            if (isAbsolutSearchExpr) {
+                //we cut off the leading sep if there is one
+                componentIdToTransform = hasLeadingSep ? componentIdToTransform.substring(1) : componentIdToTransform;
+                componentIdToTransform = componentIdToTransform.indexOf(rootNamingContainerPrefix) == 0 ? componentIdToTransform.substring(rootNamingContainerPrefix.length) : componentIdToTransform;
+                //now we prepend either the prefix or "" from the cut-off string to get the final result
+                finalIdentifier = [rootNamingContainerPrefix, componentIdToTransform].join(EMPTY_STR);
+            } else { //relative search according to the javadoc
+                //we cut off the root naming container id from the form
+                if (formClientId.indexOf(rootNamingContainerPrefix) == 0) {
+                    formClientId = formClientId.substring(rootNamingContainerPrefix.length);
+                }
+
+                //If prependId = true, the outer form id must be present in the id if same form
+                let hasPrependId = componentIdToTransform.indexOf(formClientId) == 0;
+                finalIdentifier = hasPrependId ?
+                    [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
+            // 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
         // or speedup
         for (let cnt = 0; cnt < iterValues.length; cnt++) {
@@ -629,33 +688,39 @@ export module Implementation {
                     return targetConfig;
                 //@form pushes the issuing form id into our list
                 case IDENT_FORM:
-                    ret.push(issuingForm.id.value);
+                    ret.push(remapNamingContainer(issuingForm.id.value));
                     processed[issuingForm.id.value] = true;
                     break;
                 //@this is replaced with the current issuing element id
                 case IDENT_THIS:
                     if (!(issuingElementId in processed)) {
-                        ret.push(issuingElementId);
+                        ret.push(remapNamingContainer(issuingElementId));
                         processed[issuingElementId] = true;
                     }
                     break;
                 default:
-                    ret.push(iterValues[cnt]);
+                    ret.push(remapNamingContainer(iterValues[cnt]));
                     processed[iterValues[cnt]] = true;
             }
         }
-        //We now add the target as joined list
+
         targetConfig.assign(targetKey).value = ret.join(" ");
         return targetConfig;
     }
 
     /**
      * Filter the options given with a blacklist, so that only
-     * the values required for pass-through are processed in the ajax request
+     * 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
+     * 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 filterPassThroughValues(mappedOpts: Context): Context {
+    function extractLegacyParams(mappedOpts: Options): Context {
         //we now can use the full code reduction given by our stream api
         //to filter
         return Stream.ofAssoc(mappedOpts)
@@ -663,6 +728,13 @@ export module Implementation {
             .collect(new AssocArrayCollector());
     }
 
+    function remapArrayToAssocArr(arrayedParams: [[string, any]] | {[key: string]: any}): {[key: string]: any} {
+        if(Array.isArray(arrayedParams)) {
+            return Stream.of(... arrayedParams).collect(new AssocArrayCollector());
+        }
+        return arrayedParams;
+    }
+
     function resolveGlobalConfig(): any {
         return  window?.[MYFACES]?.config ?? {};
     }

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

@@ -17,9 +17,13 @@
 /*
  * [export const] constants
  */
+
+
 export const P_PARTIAL_SOURCE = "jakarta.faces.source";
 export const PARTIAL_ID = "partialId";
+export const VIEW_ID = "myfaves.viewId";
 export const P_VIEWSTATE = "jakarta.faces.ViewState";
+export const P_CLIENT_WINDOW = "jakarta.faces.ClientWindow";
 export const P_VIEWROOT = "jakarta.faces.ViewRoot";
 export const P_VIEWHEAD = "jakarta.faces.ViewHead";
 export const P_VIEWBODY = "jakarta.faces.ViewBody";
@@ -33,7 +37,8 @@ export const EMPTY_FUNC = Object.freeze(() => {
 export const EMPTY_STR = "";
 export const EMPTY_MAP = Object.freeze({});
 
-export const HTML_VIEWSTATE = ["<input type='hidden'", "id='", P_VIEWSTATE, "' name='", P_VIEWSTATE, "' value='' />"].join(EMPTY_STR);
+export const HTML_VIEWSTATE = ["<input type='hidden'", "name='", P_VIEWSTATE, "' value='' />"].join(EMPTY_STR);
+export const HTML_CLIENT_WINDOW = ["<input type='hidden'", "' name='", P_CLIENT_WINDOW, "' value='' />"].join(EMPTY_STR);
 
 
 /*internal identifiers for options*/
@@ -46,8 +51,10 @@ export const IDENT_FORM = "@form";
 export const P_AJAX = "jakarta.faces.partial.ajax";
 export const P_EXECUTE = "jakarta.faces.partial.execute";
 export const P_RENDER = "jakarta.faces.partial.render";
+/*render override for viewbody or viewroot, in both cases an all is performed*/
+export const P_RENDER_OVERRIDE = "_myfaces.rendeOverride";
 export const P_EVT = "jakarta.faces.partial.event";
-export const P_CLIENT_WINDOW = "jakarta.faces.ClientWindow";
+
 export const P_RESET_VALUES = "jakarta.faces.partial.resetValues";
 export const P_WINDOW_ID = "jakarta.faces.windowId";
 
@@ -87,19 +94,17 @@ export const SERVER_ERROR = "serverError";
 export const CLIENT_ERROR = "clientError";
 export const TIMEOUT_EVENT = "timeout";
 
-export const CTX_PARAM_MF_INTERNAL = "_mfInternal";
-
-export const CTX_PARAM_SRC_FRM_ID = "_mfSourceFormId";
-export const CTX_PARAM_SRC_CTL_ID = "_mfSourceControlId";
-export const CTX_PARAM_TR_TYPE = "_mfTransportType";
-export const CTX_PARAM_PASS_THR = "passThrgh";
-export const CTX_PARAM_DELAY = "delay";
-export const CTX_PARAM_TIMEOUT = "timeout";
-export const CTX_PARAM_RST = "resetValues";
-export const CTX_PARAM_EXECUTE = "execute";
-
-export const STAGE_DEVELOPMENT = "Development";
+export const CTX_OPTIONS_PARAMS = "params";
+export const CTX_OPTIONS_DELAY = "delay";
+export const DELAY_NONE = 'none';
+export const CTX_OPTIONS_TIMEOUT = "timeout";
+export const CTX_OPTIONS_RESET = "resetValues";
+export const CTX_OPTIONS_EXECUTE = "execute";
 
+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 CONTENT_TYPE = "Content-Type";
 export const HEAD_FACES_REQ = "Faces-Request";
@@ -116,13 +121,12 @@ export const MULTIPART = "multipart/form-data";
 export const NO_TIMEOUT = 0;
 export const STD_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
 
-export const TAG_HEAD = "head";
-export const TAG_FORM = "form";
-export const TAG_BODY = "body";
-export const TAG_BEFORE = "before";
-export const TAG_AFTER = "after";
-
-export const TAG_ATTR = "attribute";
+export const HTML_TAG_HEAD = "HEAD";
+export const HTML_TAG_FORM = "FORM";
+export const HTML_TAG_BODY = "BODY";
+export const HTML_TAG_LINK = "LINK";
+export const HTML_TAG_SCRIPT = "SCRIPT";
+export const HTML_TAG_STYLE = "STYLE";
 
 
 export const SEL_VIEWSTATE_ELEM = "[name='" + P_VIEWSTATE + "']";
@@ -140,38 +144,40 @@ export const ATTR_VALUE = "value";
 export const ATTR_ID = "id";
 
 /*partial response types*/
-export const RESP_PARTIAL = "partial-response";
+export const XML_TAG_PARTIAL_RESP = "partial-response";
 
 /*partial commands*/
-export const CMD_CHANGES = "changes";
-export const CMD_UPDATE = "update";
-export const CMD_DELETE = "delete";
-export const CMD_INSERT = "insert";
-export const CMD_EVAL = "eval";
-export const CMD_ERROR = "error";
-export const CMD_ATTRIBUTES = "attributes";
-export const CMD_EXTENSION = "extension";
-export const CMD_REDIRECT = "redirect";
+export const XML_TAG_CHANGES = "changes";
+export const XML_TAG_UPDATE = "update";
+export const XML_TAG_DELETE = "delete";
+export const XML_TAG_INSERT = "insert";
+export const XML_TAG_EVAL = "eval";
+export const XML_TAG_ERROR = "error";
+export const XML_TAG_ATTRIBUTES = "attributes";
+export const XML_TAG_EXTENSION = "extension";
+export const XML_TAG_REDIRECT = "redirect";
+export const XML_TAG_BEFORE = "before";
+export const XML_TAG_AFTER = "after";
+export const XML_TAG_ATTR = "attribute";
+
 
 /*other constants*/
 
-export const UPDATE_FORMS = "_updateForms";
-export const UPDATE_ELEMS = "_updateElems";
+export const UPDATE_FORMS = "myfaces.updateForms";
+export const UPDATE_ELEMS = "myfaces.updateElems";
 
 //we want the head elements to be processed before we process the body
 //but after the inner html is done
-export const DEFERRED_HEAD_INSERTS = "_headElems";
+export const DEFERRED_HEAD_INSERTS = "myfaces.headElems";
 
 export const MYFACES = "myfaces";
 
-export const SEL_SCRIPTS_STYLES = "script, style, link";
-
 export const MF_NONE = "__mf_none__";
 
 export const REASON_EXPIRED = "Expired";
 
-export const APPLIED_VST = "appliedViewState";
-export const APPLIED_CLIENT_WINDOW = "appliedClientWindow";
+export const APPLIED_VST = "myfaces.appliedViewState";
+export const APPLIED_CLIENT_WINDOW = "myfaces.appliedClientWindow";
 
 export const RECONNECT_INTERVAL = 500;
 export const MAX_RECONNECT_ATTEMPTS = 25;
@@ -186,6 +192,10 @@ export const UNKNOWN = "UNKNOWN";
  * changed to a simple value passthrough
  */
 
+export function $faces(): FacesAPI {
+     return (window?.faces ?? window?.jsf) as FacesAPI;
+}
+
 export function $nsp(inputNamespace?: any): any {
      if((!inputNamespace) || !inputNamespace?.replace) {
           return inputNamespace;