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

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

@@ -16,9 +16,6 @@
 import {Config, Lang, XMLQuery} from "mona-dish";
 
 import {DQ} from "mona-dish";
-import {ExtLang} from "./Lang";
-import getMessage = ExtLang.getMessage;
-import makeException = ExtLang.makeException;
 import {
     ATTR_URL,
     EMPTY_RESPONSE,
@@ -26,8 +23,10 @@ import {
     ON_ERROR,
     ON_EVENT,
     PHASE_PROCESS_RESPONSE,
-    RESP_PARTIAL
+    XML_TAG_PARTIAL_RESP
 } from "../core/Const";
+import {ExtLang} from "./Lang";
+
 
 /**
  * a set of internal code assertions
@@ -36,6 +35,8 @@ import {
  */
 export module Assertions {
 
+
+
     export function assertRequestIntegrity(options: Config, elem: DQ): void | never {
         /*assert if the onerror is set and once if it is set it must be of type function*/
         assertFunction(options.getIf(ON_ERROR).value);
@@ -43,12 +44,12 @@ export module Assertions {
         assertFunction(options.getIf(ON_EVENT).value);
         //improve the error messages if an empty elem is passed
         //Assertions.assertElementExists(elem);
-        assert(elem.isPresent(), getMessage("ERR_MUST_BE_PROVIDED1", "{0}: source  must be provided or exist", "source element id"), "faces.ajax.request", "ArgNotSet",  )
+        assert(elem.isPresent(), ExtLang.getMessage("ERR_MUST_BE_PROVIDED1", "{0}: source  must be provided or exist", "source element id"), "faces.ajax.request", "ArgNotSet",  )
     }
 
     export function assertUrlExists(node: XMLQuery): void | never {
         if (node.attr(ATTR_URL).isAbsent()) {
-            throw Assertions.raiseError(new Error(), getMessage("ERR_RED_URL", null, "processRedirect"), "processRedirect");
+            throw Assertions.raiseError(new Error(), ExtLang.getMessage("ERR_RED_URL", null, "processRedirect"), "processRedirect");
         }
     }
 
@@ -59,7 +60,7 @@ export module Assertions {
     export function assertValidXMLResponse(responseXML: XMLQuery) : void | never  {
         assert(!responseXML.isAbsent(), EMPTY_RESPONSE, PHASE_PROCESS_RESPONSE);
         assert(!responseXML.isXMLParserError(),  responseXML.parserErrorText(EMPTY_STR), PHASE_PROCESS_RESPONSE);
-        assert(responseXML.querySelectorAll(RESP_PARTIAL).isPresent(), ERR_NO_PARTIAL_RESPONSE, PHASE_PROCESS_RESPONSE);
+        assert(responseXML.querySelectorAll(XML_TAG_PARTIAL_RESP).isPresent(), ERR_NO_PARTIAL_RESPONSE, PHASE_PROCESS_RESPONSE);
     }
 
     /**
@@ -79,7 +80,7 @@ export module Assertions {
         let finalMessage = message ?? EMPTY_STR;
 
         //TODO clean up the messy makeException, this is a perfect case for encapsulation and sane defaults
-        return makeException(error, finalTitle, finalName, "Response", caller || (((<any>arguments).caller) ? (<any>arguments).caller.toString() : "_raiseError"), finalMessage);
+        return ExtLang.makeException(error, finalTitle, finalName, "Response", caller || (((<any>arguments).caller) ? (<any>arguments).caller.toString() : "_raiseError"), finalMessage);
     }
 
     /*
@@ -103,6 +104,13 @@ export module Assertions {
     export function assertFunction(value: any, msg = EMPTY_STR, caller=EMPTY_STR, title="Assertion Error"): asserts value is Function {
         assertType(value, "function", msg, caller, title);
     }
+
+    export function assertDelay(value: any) {
+        if(!(value >= 0)) { // >= 0 abbreviation which covers all cases of non positive values,
+            // including NaN and non numeric strings, no type equality is deliberate here,
+            throw new Error("Invalid delay value: " + value);
+        }
+    }
 }
 
 

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

@@ -58,7 +58,7 @@ export class AsynchronousQueue<T extends AsyncRunnable<any>> {
         if (delay) {
             this.delayTimeout = setTimeout(() => {
                 this.appendElement(element);
-            });
+            }) as any;
         } else {
             this.appendElement(element);
         }

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

@@ -201,8 +201,8 @@ export class ExtDomQuery extends DQ {
                 return true;
             }
             let reference = element.attr("href")
-                .orElse(element.attr("src").value)
-                .orElse(element.attr("rel").value);
+                .orElseLazy(() => element.attr("src").value)
+                .orElseLazy(() => element.attr("rel").value);
 
             if (!reference.isPresent()) {
                 return true;
@@ -235,7 +235,7 @@ export class ExtDomQuery extends DQ {
      * @param deep whether the search should go into embedded shadow dom elements
      * @return a DomQuery containing the found elements
      */
-    static byId(selector: string | DomQuery | Element, deep = false): DomQuery {
+    static byId(selector: string | DomQuery | Element, deep = false): ExtDomQuery {
         const ret = DomQuery.byId(selector, deep);
         return new ExtDomQuery(ret);
     }
@@ -244,6 +244,9 @@ export class ExtDomQuery extends DQ {
         return (curScript.getAsElem(0).value as HTMLElement)?.nonce ?? curScript.attr("nonce").value;
     }
 
+    filter(func: (item: DomQuery) => boolean): ExtDomQuery {
+        return new ExtDomQuery(super.filter(func));
+    }
 }
 
 export const ExtDQ = ExtDomQuery;
@@ -254,6 +257,8 @@ export const ExtDQ = ExtDomQuery;
  */
 export class ExtConfig extends  Config {
 
+    $nspEnabled = true;
+
     constructor(root: any) {
         super(root);
     }
@@ -323,7 +328,10 @@ export class ExtConfig extends  Config {
      * @param accessPath the access paths to be remapped
      * @private returns an array of access paths with version remapped namespaces
      */
-    private remap(accessPath: any[]) {
+    private remap(accessPath: string[]): string[] {
+        if(!this.$nspEnabled) {
+            return accessPath;
+        }
         return Stream.of(...accessPath).map(key => $nsp(key)).collect(new ArrayCollector());
     }
 }

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

@@ -0,0 +1,78 @@
+/*! 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 {DomQuery, DQ, DQ$} from "mona-dish";
+import {$faces, $nsp, HTML_CLIENT_WINDOW, HTML_VIEWSTATE, P_CLIENT_WINDOW, P_VIEWSTATE} from "../core/Const";
+
+/**
+ * Builder for hidden inputs.
+ * ATM only ViewState and Client window
+ * are supported (per spec)
+ *
+ * Improves readability in the response processor!
+ */
+export class HiddenInputBuilder {
+    private namingContainerId?: string;
+    private parent?: DomQuery;
+    private readonly name: string;
+    private readonly template: string;
+
+    constructor(private selector: string) {
+        const isViewState = selector.indexOf($nsp(P_VIEWSTATE)) != -1;
+        this.name = isViewState ? P_VIEWSTATE : P_CLIENT_WINDOW
+        this.template = isViewState ? HTML_VIEWSTATE : HTML_CLIENT_WINDOW
+    }
+
+    withNamingContainerId(namingContainer: string): HiddenInputBuilder {
+        this.namingContainerId = namingContainer;
+        return this;
+    }
+
+    withParent(parent: DomQuery): HiddenInputBuilder {
+        this.parent = parent;
+        return this;
+    }
+
+
+    build(): DomQuery {
+        const SEP = $faces().separatorchar;
+
+        let existingStates = DQ$(`[name*='${$nsp(this.name)}']`);
+        let cnt = existingStates.stream.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;
+        //the maximum  new ident is the current max + 1
+        cnt++;
+
+
+        const newElement = DQ.fromMarkup($nsp(this.template));
+        newElement.id.value = ((this.namingContainerId?.length) ?
+            [this.namingContainerId,  $nsp(this.name),  cnt]:
+            [$nsp(this.name),  cnt]).join(SEP);
+
+        //name must be prefixed with the naming container id as well according to the jsdocs
+        newElement.name.value = (this.namingContainerId?.length) ?
+            [this.namingContainerId,  $nsp(this.name)].join(SEP): $nsp(this.name);
+
+        this?.parent?.append(newElement);
+        return newElement;
+    }
+}

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

@@ -13,13 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * todo replace singleton with module definition
- *
  */
 
 import {Lang as LangBase, Config, Optional, DomQuery, DQ, Stream} from "mona-dish";
 import {Messages} from "../i18n/Messages";
-import {EMPTY_STR, TAG_FORM} from "../core/Const";
+import {EMPTY_STR, HTML_TAG_FORM} from "../core/Const";
 import {getEventTarget} from "../xhrCore/RequestDataResolver";
 
 
@@ -160,25 +158,25 @@ export module ExtLang {
     export function getForm(elem: Element, event ?: Event): DQ | never {
 
         let queryElem = new DQ(elem);
-        let eventTarget = new DQ(getEventTarget(event));
+        let eventTarget = (event) ?  new DQ(getEventTarget(event)) : DomQuery.absent;
 
-        if (queryElem.isTag(TAG_FORM)) {
+        if (queryElem.isTag(HTML_TAG_FORM)) {
             return queryElem;
         }
 
         //html 5 for handling
-        if (queryElem.attr(TAG_FORM).isPresent()) {
-            let formId = queryElem.attr(TAG_FORM).value;
+        if (queryElem.attr(HTML_TAG_FORM).isPresent()) {
+            let formId = queryElem.attr(HTML_TAG_FORM).value;
             let foundForm = DQ.byId(formId, true);
             if (foundForm.isPresent()) {
                 return foundForm;
             }
         }
 
-        let form = queryElem.parents(TAG_FORM)
-            .orElseLazy(() => queryElem.byTagName(TAG_FORM, true))
-            .orElseLazy(() => eventTarget.parents(TAG_FORM))
-            .orElseLazy(() => eventTarget.byTagName(TAG_FORM))
+        let form = queryElem.firstParent(HTML_TAG_FORM)
+            .orElseLazy(() => queryElem.byTagName(HTML_TAG_FORM, true))
+            .orElseLazy(() => eventTarget.firstParent(HTML_TAG_FORM))
+            .orElseLazy(() => eventTarget.byTagName(HTML_TAG_FORM))
             .first();
 
         assertFormExists(form);

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

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 import {
-    EMPTY_STR,
+    EMPTY_STR, ERROR,
     ERROR_MESSAGE,
     ERROR_NAME,
     RESPONSE_TEXT,
-    RESPONSE_XML,
+    RESPONSE_XML, SERVER_ERROR,
     SOURCE,
     STATUS,
     UNKNOWN
@@ -49,7 +49,8 @@ export enum ErrorType {
 export class ErrorData extends EventData implements IErrorData {
 
     type: string = "error";
-    source: string;
+    source: HTMLElement;
+    sourceId: string;
     errorName: string;
     errorMessage: string;
 
@@ -63,12 +64,14 @@ export class ErrorData extends EventData implements IErrorData {
     serverErrorMessage: string;
     message: string;
 
-    constructor(source: string, errorName: string, errorMessage: string, responseText: string = null, responseXML: any = null, responseCode: string = "200", status: string = "UNKNOWN", type = ErrorType.CLIENT_ERROR) {
+    constructor(source: string, errorName: string, errorMessage: string, responseText: string = null, responseXML: any = null, responseCode: string = "200", status: string = "", type = ErrorType.CLIENT_ERROR) {
         super();
-        this.source = source;
-        this.type = "error";
+        this.source = document.getElementById(source);
+        this.sourceId = source;
+        this.type = ERROR;
         this.errorName = errorName;
-        this.message = this.errorMessage = errorMessage;
+        //tck requires that the type is prefixed to the message itself (jsdoc also) in case of a server error
+        this.message = this.errorMessage = (type == SERVER_ERROR) ? type + ": " + errorMessage : errorMessage;
         this.responseCode = responseCode;
         this.responseText = responseText;
         this.status = status;
@@ -81,10 +84,10 @@ export class ErrorData extends EventData implements IErrorData {
     }
 
     static fromClient(e: Error): ErrorData {
-        return new ErrorData("client", e?.name ?? '', e?.message ?? '', e?.stack ?? '');
+        return new ErrorData((e as any)?.source ?? "client", e?.name ?? EMPTY_STR, e?.message ?? EMPTY_STR, e?.stack ?? EMPTY_STR);
     }
 
-    static fromHttpConnection(source: any, name: string, message: string, responseText, responseCode: number, status: string = 'UNKNOWN'): ErrorData {
+    static fromHttpConnection(source: any, name: string, message: string, responseText, responseCode: number, status: string = EMPTY_STR): ErrorData {
         return new ErrorData(source, name, message, responseText, responseCode, `${responseCode}`, status, ErrorType.HTTP_ERROR);
     }
 
@@ -98,11 +101,13 @@ export class ErrorData extends EventData implements IErrorData {
         let status = getMsg(context, STATUS);
         let responseText = getMsg(context, RESPONSE_TEXT);
         let responseXML = getMsg(context, RESPONSE_XML);
+
+
         return new ErrorData(source, errorName, errorMessage, responseText, responseXML, errorCode + EMPTY_STR, status, errorType);
     }
 
     private static getMsg(context, param) {
-        return getMessage(context.getIf(param).orElse(UNKNOWN).value);
+        return getMessage(context.getIf(param).orElse(EMPTY_STR).value);
     }
 
     static fromServerError(context: Config): ErrorData {

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {Config, DQ} from "mona-dish";
-import {BEGIN, CTX_PARAM_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
+import {BEGIN, CTX_PARAM_REQ_PASS_THR, EVENT, P_PARTIAL_SOURCE, SOURCE} from "../core/Const";
 
 export class EventData implements IEventData{
     type: string;
@@ -33,7 +33,7 @@ export class EventData implements IEventData{
 
         let sourceId: string = context.getIf(SOURCE)
             .orElseLazy(() => context.getIf(P_PARTIAL_SOURCE).value)
-            .orElseLazy(() => context.getIf(CTX_PARAM_PASS_THR, P_PARTIAL_SOURCE).value)
+            .orElseLazy(() => context.getIf(CTX_PARAM_REQ_PASS_THR, P_PARTIAL_SOURCE).value)
             .value;
         if (sourceId) {
             eventData.source = DQ.byId(sourceId, true).first().value.value;

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

@@ -32,7 +32,6 @@ export interface IResponseProcessor {
      */
     replaceHead(shadowHead: XMLQuery | DQ): void;
 
-
     /**
      * adds new elements to the head
      *
@@ -40,6 +39,14 @@ export interface IResponseProcessor {
      */
     addToHead(newElements: XMLQuery | DQ): void;
 
+
+    /**
+     * adds new elements to the head in a deferred manner
+     *
+     * @param newElements the elements which need addition
+     */
+    addToHeadDeferred(newElements: XMLQuery | DQ): void;
+
     /**
      * replace the body
      *

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

@@ -16,18 +16,23 @@
 
 import {Config, DomQuery, DQ} from "mona-dish";
 import {
-    CTX_PARAM_DELAY,
-    CTX_PARAM_TIMEOUT,
+    $faces,
+    $nsp,
+    CTX_OPTIONS_DELAY,
+    CTX_OPTIONS_TIMEOUT,
+    DELAY_NONE,
     EMPTY_FUNC,
     EMPTY_STR,
     ENCODED_URL,
-    MF_NONE,
+    P_VIEWSTATE,
     REQ_TYPE_GET,
     REQ_TYPE_POST
 } from "../core/Const";
 import {XhrFormData} from "./XhrFormData";
 import {ExtLang} from "../util/Lang";
 import {ExtConfig, ExtDomQuery} from "../util/ExtDomQuery";
+import {Assertions} from "../util/Assertions";
+
 
 /**
  * Resolver functions for various aspects of the request data
@@ -67,20 +72,26 @@ export function resolveFinalUrl(sourceForm: DomQuery, formData: XhrFormData, aja
  * it is either the id or the parent form of the element or an embedded form
  * of the element
  *
- * @param requestCtx
  * @param elem
  * @param event
  */
-export function resolveForm(requestCtx: Config, elem: DQ, event: Event): DQ {
-    const configId = requestCtx.value?.myfaces?.form ?? MF_NONE;
-    return DQ
-        .byId(configId, true)
-        .orElseLazy(() => ExtLang.getForm(elem.getAsElem(0).value, event));
+export function resolveForm(elem: DQ, event: Event): DQ {
+    return ExtLang.getForm(elem.getAsElem(0).value, event);
+}
+
+export function resolveViewId(form: DQ): string {
+    const viewState = form.querySelectorAll(`input[type='hidden'][name*='${$nsp(P_VIEWSTATE)}']`).id.orElse("").value;
+    const divider = $faces().separatorchar;
+    const viewId = viewState.split(divider, 2)[0];
+    const viewStateViewId = viewId.indexOf($nsp(P_VIEWSTATE)) === -1 ? viewId : "";
+    // myfaces specific, we in non portlet environments prepend the viewId
+    // even without being in a naming container, the other components ignore that
+    return form.id.value.indexOf(viewStateViewId) === 0 ? viewStateViewId : "";
 }
 
 export function resolveTimeout(options: Config): number {
     let getCfg = ExtLang.getLocalOrGlobalConfig;
-    return options.getIf(CTX_PARAM_TIMEOUT).value ?? getCfg(options.value, CTX_PARAM_TIMEOUT, 0);
+    return options.getIf(CTX_OPTIONS_TIMEOUT).value ?? getCfg(options.value, CTX_OPTIONS_TIMEOUT, 0);
 }
 
 /**
@@ -89,9 +100,15 @@ export function resolveTimeout(options: Config): number {
  * @param options ... the options object, in most cases it will host the delay value
  */
 export function resolveDelay(options: Config): number {
-    let getCfg = ExtLang.getLocalOrGlobalConfig;
-
-    return options.getIf(CTX_PARAM_DELAY).value ?? getCfg(options.value, CTX_PARAM_DELAY, 0);
+    // null, 'none', or undefined will automatically be mapped to 0 aka no delay
+    // the config delay will be dropped not needed anymore, it does not really
+    // make sense anymore now that it is part of a local spec
+    let ret = options.getIf(CTX_OPTIONS_DELAY).orElse(0).value;
+    // if delay === none, no delay must be used, aka delay 0
+    ret = (DELAY_NONE === ret) ? 0 : ret;
+    // negative, or invalid values will automatically get a js exception
+    Assertions.assertDelay(ret);
+    return ret;
 }
 
 /**
@@ -138,14 +155,15 @@ export function getEventTarget(evt: Event): Element {
  * @param opts
  * @param el
  */
-export function resolveDefaults(event: Event, opts: any = {}, el: Element | string = null) {
+export function resolveDefaults(event: Event, opts: Options | [[string, any]] , el: Element | string = null): any {
     //deep copy the options, so that further transformations to not backfire into the callers
-    const resolvedEvent = event,
-        options = new ExtConfig(opts).deepCopy,
-        elem = DQ.byId(el || <Element>resolvedEvent.target, true),
-        elementId = elem.id.value, requestCtx = new ExtConfig({}),
-        internalCtx = new ExtConfig({}), windowId = resolveWindowId(options),
-        isResetValues = true === options.value?.resetValues;
-
-    return {resolvedEvent, options, elem, elementId, requestCtx, internalCtx, windowId, isResetValues};
+    const elem = DQ.byId(el || <Element>event.target, true);
+    const options = new ExtConfig(opts).deepCopy as ExtConfig;
+    return {
+        options: options,
+        elem: elem,
+        elementId: elem.id.value,
+        windowId: resolveWindowId(options),
+        isResetValues: true === options.value?.resetValues
+    };
 }

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

@@ -25,7 +25,7 @@ import {
     CTX_PARAM_SRC_FRM_ID,
     SEL_RESPONSE_XML,
     SOURCE,
-    TAG_FORM,
+    HTML_TAG_FORM,
     UPDATE_ELEMS,
     UPDATE_FORMS,
     DEFERRED_HEAD_INSERTS
@@ -106,9 +106,9 @@ export function resolveSourceForm(internalContext: Config, elem: DQ): DQ {
     let sourceFormId = internalContext.getIf(CTX_PARAM_SRC_FRM_ID);
     let sourceForm = new DQ(sourceFormId.isPresent() ? document.forms[sourceFormId.value] : null);
 
-    sourceForm = sourceForm.orElseLazy(() => elem.parents(TAG_FORM))
-        .orElseLazy(() => elem.querySelectorAll(TAG_FORM))
-        .orElseLazy(() => DQ.querySelectorAll(TAG_FORM));
+    sourceForm = sourceForm.orElseLazy(() => elem.firstParent(HTML_TAG_FORM))
+        .orElseLazy(() => elem.querySelectorAll(HTML_TAG_FORM))
+        .orElseLazy(() => DQ.querySelectorAll(HTML_TAG_FORM));
 
     return sourceForm;
 }

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

@@ -20,23 +20,23 @@ import {ResponseProcessor} from "./ResponseProcessor";
 import {IResponseProcessor} from "./IResponseProcessor";
 import {
     $nsp,
-    CMD_ATTRIBUTES,
-    CMD_CHANGES,
-    CMD_DELETE,
-    CMD_ERROR,
-    CMD_EVAL,
-    CMD_EXTENSION,
-    CMD_INSERT,
-    CMD_REDIRECT,
-    CMD_UPDATE, P_RESOURCE,
+    XML_TAG_ATTRIBUTES,
+    XML_TAG_CHANGES,
+    XML_TAG_DELETE,
+    XML_TAG_ERROR,
+    XML_TAG_EVAL,
+    XML_TAG_EXTENSION,
+    XML_TAG_INSERT,
+    XML_TAG_REDIRECT,
+    XML_TAG_UPDATE, P_RESOURCE,
     P_VIEWBODY,
     P_VIEWHEAD,
     P_VIEWROOT,
     PARTIAL_ID,
-    RESP_PARTIAL,
+    XML_TAG_PARTIAL_RESP,
     RESPONSE_XML,
-    TAG_AFTER,
-    TAG_BEFORE
+    XML_TAG_AFTER,
+    XML_TAG_BEFORE
 } from "../core/Const";
 import {resolveContexts, resolveResponseXML} from "./ResonseDataResolver";
 import {ExtConfig} from "../util/ExtDomQuery";
@@ -67,7 +67,7 @@ export module Response {
         internalContext.assign(RESPONSE_XML).value = responseXML;
 
         // we now process the partial tags, or in none given raise an error
-        responseXML.querySelectorAll(RESP_PARTIAL)
+        responseXML.querySelectorAll(XML_TAG_PARTIAL_RESP)
             .each(item => processPartialTag(<XMLQuery>item, responseProcessor, internalContext));
 
         // We now process the viewStates, client windows and the elements to be evaluated are delayed.
@@ -89,18 +89,18 @@ export module Response {
      function processPartialTag(node: XMLQuery, responseProcessor: IResponseProcessor, internalContext) {
 
         internalContext.assign(PARTIAL_ID).value = node.id;
-        const SEL_SUB_TAGS = [CMD_ERROR, CMD_REDIRECT, CMD_CHANGES].join(",");
+        const SEL_SUB_TAGS = [XML_TAG_ERROR, XML_TAG_REDIRECT, XML_TAG_CHANGES].join(",");
 
         // now we can process the main operations
         node.querySelectorAll(SEL_SUB_TAGS).each((node: XMLQuery) => {
             switch (node.tagName.value) {
-                case CMD_ERROR:
+                case XML_TAG_ERROR:
                     responseProcessor.error(node);
                     break;
-                case CMD_REDIRECT:
+                case XML_TAG_REDIRECT:
                     responseProcessor.redirect(node);
                     break;
-                case CMD_CHANGES:
+                case XML_TAG_CHANGES:
                     processChangesTag(node, responseProcessor);
                     break;
             }
@@ -110,7 +110,7 @@ export module Response {
 
     let processInsert = function (responseProcessor: IResponseProcessor, node: XMLQuery) {
          // path1 insert after as child tags
-         if(node.querySelectorAll([TAG_BEFORE, TAG_AFTER].join(",")).length) {
+         if(node.querySelectorAll([XML_TAG_BEFORE, XML_TAG_AFTER].join(",")).length) {
              responseProcessor.insertWithSubTags(node);
          } else { // insert before after with id
              responseProcessor.insert(node);
@@ -125,31 +125,31 @@ export module Response {
      * @param responseProcessor
      */
      function processChangesTag(node: XMLQuery, responseProcessor: IResponseProcessor): boolean {
-        const ALLOWED_TAGS = [CMD_UPDATE, CMD_EVAL, CMD_INSERT, CMD_DELETE, CMD_ATTRIBUTES, CMD_EXTENSION].join(", ");
+        const ALLOWED_TAGS = [XML_TAG_UPDATE, XML_TAG_EVAL, XML_TAG_INSERT, XML_TAG_DELETE, XML_TAG_ATTRIBUTES, XML_TAG_EXTENSION].join(", ");
         node.querySelectorAll(ALLOWED_TAGS).each(
             (node: XMLQuery) => {
                 switch (node.tagName.value) {
-                    case CMD_UPDATE:
+                    case XML_TAG_UPDATE:
                         processUpdateTag(node, responseProcessor);
                         break;
 
-                    case CMD_EVAL:
+                    case XML_TAG_EVAL:
                         responseProcessor.eval(node);
                         break;
 
-                    case CMD_INSERT:
+                    case XML_TAG_INSERT:
                         processInsert(responseProcessor, node);
                         break;
 
-                    case CMD_DELETE:
+                    case XML_TAG_DELETE:
                         responseProcessor.delete(node);
                         break;
 
-                    case CMD_ATTRIBUTES:
+                    case XML_TAG_ATTRIBUTES:
                         responseProcessor.attributes(node);
                         break;
 
-                    case CMD_EXTENSION:
+                    case XML_TAG_EXTENSION:
                         break;
                 }
             }