@adobe/acc-js-sdk 1.1.14 → 1.1.15

package/docs/_posts/2022-10-14-welcome.html

@@ -129,7 +129,7 @@ console.log(`About to call method '${methodName}' of scope '${scopeName}'`);
     returnedValue = undefined;
   }
   // If the API returns one parameter which is an object, the return it directly.
-  // If not (return value is a litteral), then use a JSON with the return parameter name
+  // If not (return value is a literal), then use a JSON with the return parameter name
   else if (outNames.length == 1) {
     if (result && typeof result == "object")
       returnedValue = result;

package/docs/changeLog.html

@@ -2,6 +2,13 @@
 layout: page
 title: Change Log
 ---
+<section class="changelog"><h1>Version 1.1.15</h1>
+  <h2>2022/11/28</h2>
+  
+  <li>Fix an issue with SimpleJson serialization. See <a href="https://opensource.adobe.com/acc-js-sdk/simpleJson.html">SimpleJson documentation</a> for more details, and in particular the <b>Compatibility Notes</b> section</li>
+  <li>Fix credentials passing for fileUpload and getReportData methods. This is still a temporary fix until those APIs are made IMS compatible.</li>
+</section>
+
 <section class="changelog"><h1>Version 1.1.14</h1>
   <h2>2022/11/25</h2>
   
@@ -202,7 +209,7 @@ For breaking changes see the [migration guide](MIGRATION.md)
 <li><b>getEntityIfMoreRecent</b> now takes an additional parameter which allows to specify and force a representation (xml, json...)
 <li>New helper function <b>DomUtil.isArray</b> to test if a JavaScript object is an array
 <li>New <b>EntityAccessor</b> object which allows to get attributes and child elements from xml or json objects, regardless of their representation
-<li>New <b>escapeXtk</b> function to escape litteral values in Xtk expression. Can be used as a function or as a tagged template litteral
+<li>New <b>escapeXtk</b> function to escape literal values in Xtk expression. Can be used as a function or as a tagged template literal
 <li>New function <b>XtkCaster._variantStorageAttribute</b> which returns the name of a schema attribute used to store variant value types. The name of the attribute depends on the type: stringValue, longValue, etc.
 <li>Support for non static method that mutate the object on which they apply. For instance, the <b>xtk:queryDef#SelectAll</b>
 <li>Added samples in the samples/ folder
@@ -229,7 +236,7 @@ _Breaking changes in 1.0.0_
 <li>Changes in the <b>sdk.init</b>, <b>Client</b> constructor, and <b>logon</b> functions. Now using <b>ConnectionParameters</b> and <b>Credentials</b> objects to configure a Campaign connection
 <li>Client object members are now private: access to representation, etc. attributes is not allowed anymore except for <b>NLWS</b>, <b>XtkCaster</b>, and <b>DomUtil</b>
 <li>Access to the <b>sessionInfo</b> object after <b>logon</b> can be done via the new <b>getSessionInfo</b> call
-<li>Options cache internal strucutre change: option values in the cache are now object litterals containing the option value, type, and raw value (which may not be casted to the expected type yet)
+<li>Options cache internal strucutre change: option values in the cache are now object literals containing the option value, type, and raw value (which may not be casted to the expected type yet)
 <li>Connecting to mid-sourcing (or other Campaign instances which are defined by an external account) is now done with the <b>ConnectionParameters.ofExternalAccount</b> function. As a consequence, <b>getSecretKeyCipher</b> is now private and deprecated
 <li>CampaignException object signature changed (but was not previously exposed)
 <li>The client-side bundle is now generated in the <b>dist/bundle.js</b> file instead of <b>bundle.js</b>

package/docs/escaping.html

@@ -4,7 +4,7 @@ title: Escaping
 ---
 
 
-<p>It's common to use variables in query conditions. For instance, in the above example, you'll want to query an account by name instead of using the hardcoded <b>ffda</b> name. The <b>expr</b> attribute takes an XTK expression as a parameter, and <b>ffda</b> is a string litteral in an xtk expression.</p>
+<p>It's common to use variables in query conditions. For instance, in the above example, you'll want to query an account by name instead of using the hardcoded <b>ffda</b> name. The <b>expr</b> attribute takes an XTK expression as a parameter, and <b>ffda</b> is a string literal in an xtk expression.</p>
 
 <p>To prevent xtk ingestions vulnerabilities, you should not concatenate strings and write code such as expr: "@name = '" + name + "'": if the value of the name 
   parameter contains single quotes, your code will not work, but could also cause vulnerabilities.
@@ -13,19 +13,19 @@ title: Escaping
 
 <h1>sdk.escapeXtk</h1>
 
-<p>The <b>sdk.escapeXtk</b> can be used to properly escape string litterals in xtk expressions. The function will also surround the escaped value with single quotes.</p>
+<p>The <b>sdk.escapeXtk</b> can be used to properly escape string literals in xtk expressions. The function will also surround the escaped value with single quotes.</p>
 
 <p>You can use string concatenation like this. Note the lack of single quotes around the value.</p>
 <pre class="code">
 { expr: "@name=" + sdk.escapeXtk(name) }
 </pre>
 
-<p>or a template litteral</p>
+<p>or a template literal</p>
 <pre class="code">
 `{ expr: "@name=${sdk.escapeXtk(name)}" }`
 </pre>
 
-<p>The <b>escapeXtk</b> function can also be used to create tagged string litterals. This leads to a much shorter syntax. Note that with this syntax, only the parameter values of the template litteral are escaped</p>
+<p>The <b>escapeXtk</b> function can also be used to create tagged string literals. This leads to a much shorter syntax. Note that with this syntax, only the parameter values of the template literal are escaped</p>
 <pre class="code">
 sdk.escapeXtk`{ expr: "@name=${name}" }`
 </pre>

package/docs/simpleJson.html

@@ -4,7 +4,7 @@ title: SimpleJson format
 ---
 
 <p>The <b>SimpleJson</b> format is the format used by default by the SDK to conver between Campaign XML and JSON</p>
-
+<p></p>
 
 <ul>
   <li>XML attributes are JSON properties (without the “@” sign)</li>
@@ -27,6 +27,7 @@ title: SimpleJson format
 </pre>
 
 
+<h1>XML Root</h1>
 <p>The XML root element tag is automatically determined by the SDK as it's generating the XML, usually from the current schema name.</p>
 
 <pre class="code">
@@ -34,15 +35,21 @@ XML:     &lt;root/>
 JSON:    {}
 </pre>
 
-<p>XML attributes are mapped to JSON attributes with the same name, whose litteral value can be a string, number, or boolean. There's no "@" sign in the JSON attribute name.
-Values in JSON attributes can be indifferently typed (ex: number, boolean), or strings (ex: "3" instead of just 3) depending if the conversion could determine the attribute type or not. 
-API users should expect and handle both value and use the `XtkCaster` object to ensure proper conversion when using.</p>
+
+
+
+<h1>XML Attributes</h1>
+<p>XML attributes are mapped to JSON attributes with the same name, whose literal value can be a string, number, or boolean. There's no "@" sign in the JSON attribute name.
+Values in JSON attributes can be either typed (ex: number, boolean), or strings (ex: "3" instead of just 3) depending if the conversion could determine the attribute type or not. 
+API users should expect and handle both value and use the <b>XtkCaster</b> object to ensure proper conversion.</p>
 
 <pre class="code">
 XML     &lt;root hello="world" count="3" ok="true"/>
 JSON:   { hello:"world", count:"3", ok:"true" }
 </pre>
 
+
+<h1>XML Elements</h1>
 <p>XML elements are mapped to JSON objects</p>
 
 <pre class="code">
@@ -64,7 +71,9 @@ XML:    &lt;root>&lt;item id=1/>&lt;item id=2/>&lt;/root>
 JSON:   { item: [ { id:"1" }, { id:"2" } ] }
 </pre>
 
-<p>Text of XML element is handle with the <b>$</b> sign in the JSON attribute name, or with a child JSON object name <b>$</b></p>
+
+<h1>Text nodes</h1>
+<p>Text of XML element is handled with the <b>$</b> sign in the JSON attribute name, or with a child JSON object name <b>$</b></p>
 
 <p>Text of the root element</p>
 <pre class="code">
@@ -86,3 +95,67 @@ XML:    &lt;root>&lt;item>Hello&lt;child id="1"/>
         &lt;/root>
 JSON:   { item: { $: "Hello", child: { id:"1" } }
 </pre>
+
+<p>Normally Campaign will not generate XML with elements containing multiple sibling text nodes. If this should happen, the SDK will consider them as a single text value, i.e. it will concatenate the contents of each text and CDATA node as if there was only one. However, whitespaces are processed independently for each text node.
+</p>
+
+<h1>Whitespaces</h1>
+<p>In XML documents, whitespaces can be either significant or insignificant. The SDK uses the following rules to strip whitespaces, which correspond to how Campaign specifically uses XML</p>
+<p> </p>
+<ul>
+<li>The characters " ", "\t", "\r" and "\n" are considered whitespaces</li>
+<li>CDATA sections are kept unchanged, i.e. whitespaces are preserved exactly</li>
+<li>For TEXT nodes directly under the root node are, whitespaces will be trimmed as explained below</li>
+<li>For element nodes which only contain text and possibly attributes (for instance &lt;node&gt;value&lt;/node&gt;</li>, the text is kept unchanged, i.e. whitespaces are preserved exactly</li>
+<li>For element nodes which have child elements, whitespaces will be trimmed as explained below</li>
+<li>For the root element, whitespaces are always trimmed</li>
+</ul>
+<p> </p>
+<p>
+  Whitespace trimming consists of removing all the leading and trailing whitespaces of each text node and concatenating all text node values. If the resulting value is empty, the text node is ignored. The rationale is to remove insignificant spaces created when formatting XML documents
+</p>
+
+
+<h1>Exceptions</h1>
+
+<h2>When an attribute has the same name of an element</h2>
+
+<p>If an element contains another element and an attribute which have the same name, the attribute name is prefixed with the "@" character</p>
+<pre class="code">
+XML:    &lt;root timezone="Europe/Paris">
+          &lt;timezone>Europe/Paris&lt;/timezone>
+        &lt;/root>
+JSON:   { "@timezone": "Europe/Paris", 
+          timezone: { "$": "Europe/Paris" } }
+</pre>
+
+
+<h1>Arrays of text elements</h1>
+<p></p>
+<pre class="code">
+  XML:    &lt;root>
+            &lt;item>One&lt;/item>
+            &lt;item>Two&lt;/item>
+          &lt;/root>
+  JSON:   { item: [
+            { $: "One" },
+            { $: "Two" }
+          ] }
+  </pre>
+  
+
+
+<h1>Compatibility notes</h1>
+
+<p>
+  A few gaps were identified regarding SimpleJson format when converting from XML to JSON. They were fixed in release 1.1.15 and may introduce some behavior changes for cases which were ambiguous
+</p>
+<p> </p>
+<ul>
+  <li>When XML element has both a text content and attributes or child elements</li>
+  <li>When root element has only text</li>
+  <li>When XML element has both an attribute and a child element with the same name</li>
+  <li>When array contains element which only have text</li>
+  <li>When XML is formatted (and therefore has insignificant whitespaces)</li>
+  <li>XML collections (i.e. when root node ends with “-collection”) would sometimes contain a JSON property “#text”</li>  
+</ul>

package/docs/transport.html

@@ -27,7 +27,7 @@ title: The Transport Protocol
 
 <p>If the request is successful, a promise is returned with the result payload, as a string.</p>
 
-<p>If the request fails, the promise is rejected with an error object with class <b>HttpError</b>, a litteral with the following attributes:</p>
+<p>If the request fails, the promise is rejected with an error object with class <b>HttpError</b>, a literal with the following attributes:</p>
 <ul>
     <li><b>statusCode</b> is the HTTP status code, such as 404, 500, etc.</li>
     <li><b>statusText</b> is the HTTP status text coming with the error</li>
@@ -39,7 +39,7 @@ title: The Transport Protocol
 <p>The transport can be overriden by using the <b>client.setTransport</b> call and passing it a transport function, i.e. an async function which</p>
 
 <ul>
-    <li>Takes a <b>Request</b> object litteral as a parameter</li>
+    <li>Takes a <b>Request</b> object literal as a parameter</li>
     <li>Returns a the request result in a promise</li>
     <li>Returns a rejected promise containing an <b>HttpError</b> in case of failure</li>
 </ul>

package/docs/xtkQueryDef.html

@@ -74,7 +74,7 @@ const extAccount = await query.executeQuery();
 
 
 <h1>Escaping</h1>
-<p>It's common to use variables in query conditions. For instance, in the above example, you'll want to query an account by name instead of using the hardcoded <b>ffda</b> name. The <b>expr</b> attribute takes an XTK expression as a parameter, and <b>ffda</b> is a string litteral in an xtk expression.</p>
+<p>It's common to use variables in query conditions. For instance, in the above example, you'll want to query an account by name instead of using the hardcoded <b>ffda</b> name. The <b>expr</b> attribute takes an XTK expression as a parameter, and <b>ffda</b> is a string literal in an xtk expression.</p>
 
 <p>To prevent xtk ingestions vulnerabilities, you should not concatenate strings and write code such as expr: "@name = '" + name + "'": if the value of the name 
   parameter contains single quotes, your code will not work, but could also cause vulnerabilities.

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.14",
+  "version": "1.1.15",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.14",
+  "version": "1.1.15",
   "description": "ACC Javascript SDK",
   "main": "src/index.js",
   "homepage": "https://github.com/adobe/acc-js-sdk#readme",

package/src/campaign.js

@@ -28,7 +28,7 @@ const { Util } = require("./util.js");
   static INVALID_CREDENTIALS_TYPE(type, details)          { return new CampaignException(undefined, 400, 16384, `SDK-000000 Invalid credentials type '${type}'`, details); }
   static CANNOT_GET_CREDENTIALS_USER(type)                { return new CampaignException(undefined, 400, 16384, `SDK-000001 Cannot get user for Credentials of type '${type}'`); }
   static CANNOT_GET_CREDENTIALS_PASSWORD(type)            { return new CampaignException(undefined, 400, 16384, `SDK-000002 Cannot get password for Credentials of type '${type}'`); }
-  static INVALID_CONNECTION_OPTIONS(options)              { return new CampaignException(undefined, 400, 16384, `SDK-000003 Invalid options parameter (type '${typeof options}'). An object litteral is expected`); }
+  static INVALID_CONNECTION_OPTIONS(options)              { return new CampaignException(undefined, 400, 16384, `SDK-000003 Invalid options parameter (type '${typeof options}'). An object literal is expected`); }
   static INVALID_REPRESENTATION(representation, details)  { return new CampaignException(undefined, 400, 16384, `SDK-000004 Invalid representation '${representation}'.`, details); }
   static CREDENTIALS_FOR_INVALID_EXT_ACCOUNT(name, type)  { return new CampaignException(undefined, 400, 16384, `SDK-000005 Cannot created connection parameters for external account '${name}': account type ${type} not supported`); }
   static BAD_PARAMETER(name, value, details)              { return new CampaignException(undefined, 400, 16384, `SDK-000006 Bad parameter '${name}' with value '${value}'`, details); }

package/src/client.js

@@ -546,16 +546,14 @@ const fileUploader = (client) => {
                     }
                     const data = new FormData();
                     data.append('file_noMd5', file);
-                    //TODO: Needs to be refactored after cookie issue get resolved.
                     client._makeHttpCall({
                         url: `${client._connectionParameters._endpoint}/nl/jsp/uploadFile.jsp`,
                         processData: false,
-                        credentials: 'include',
                         method: 'POST',
                         data: data,
                         headers: {
-                            'x-security-token': client._securityToken,
-                            'Cookie': '__sessiontoken=' + client._sessionToken,
+                            'X-Security-Token': client._securityToken,
+                            'X-Session-Token': client._sessionToken,
                         }
                     }).then((okay) => {
                         if (!okay.startsWith('Ok')) {
@@ -1794,11 +1792,10 @@ class Client {
                 url: `${this._connectionParameters._endpoint}/report/${callContext.reportName}?${encodeURI(`_noRender=true&_schema=${callContext.schema}&_context=${callContext.context}&_selection=${callContext.selection}`)}&_selectionCount=${selectionCount}`,
                 headers: {
                     'X-Security-Token': this._securityToken,
-                    'Cookie': '__sessiontoken=' + this._sessionToken, 
+                    'X-Session-Token': this._sessionToken,
                     'Content-Type': 'application/x-www-form-urlencoded'
                 },
                 method: 'POST',
-                credentials: 'include',
                 data : qsStringify(callContext.formData)
             };
             

package/src/domUtil.js

@@ -386,6 +386,7 @@ class DomUtil {
     static _getTextIfTextNode(xml) {
         const child = xml.firstChild;
         if (!child) return null;                   // no children
+        if (xml.hasAttributes()) return null;      // no attributes
         if (child.nextSibling) return null;        // more than 1 child
         if (child.nodeType !== 3 && child.nodeType !== 4) return null;
         const text = child.nodeValue;
@@ -400,29 +401,37 @@ class DomUtil {
      * @param {Element} xml the DOM element to convert to JSON
      * @param {Object} json the object literal to write to
      * @param {string} flavor the JSON flavor: "SimpleJson" or "BadgerFish"
+     * @param {Object} parentJson parent JSON node during recursion. Is undefined for first call
+     * @param {boolean} forceTextAs is set during recursion (SimpleJson format) to force serialization of text nodes using "$: value" syntax 
+     *                  instead of "$name: value" syntax. This is necessary to process collections and arrays of elements which only 
+     *                  contain text nodes.
      */
-    static _toJSON(xml, json, flavor) {
-        if (xml.hasAttributes()) {
-            var attributes = xml.attributes;
-            for (var i=0; i<attributes.length; i++) {
-                var att = attributes[i];
-                var attName = (flavor == "BadgerFish" ? "@" : "") + att.name;
-                json[attName] = att.value;
-            }
-        }
+    static _toJSON(xml, json, flavor, parentJson, forceTextAs$) {
 
         // Heuristic to determine if element is an object or an array
         const isCollection = xml.tagName.length > 11 && xml.tagName.substr(xml.tagName.length-11) == '-collection';
 
+        // Figure out which elements are arrays. Keep a count of elements for each tag name.
+        // When count >1 we consider this tag name to be an array
+        var hasChildElements = false; // Will be set if there is at least one child element
+        const countByTag = {};
         var child = xml.firstChild;
         while (child) {
-            var childName = child.nodeName;
-            if (isCollection && (json[childName] === null || json[childName] === undefined))
-                json[childName] = [ ];
-            var isArray = !!json[childName];
-            if (isArray && !Util.isArray(json[childName]))
-                json[childName] = [ json[childName] ];
-            if (child.nodeType == 1) {  // element
+            if (child.nodeType == 1) {
+                const childName = child.nodeName;
+                if (countByTag[childName] === undefined) countByTag[childName] = 1;
+                else countByTag[childName] = countByTag[childName] + 1;
+                hasChildElements = true;
+            }
+            child = child.nextSibling;
+        }
+        
+        child = xml.firstChild;
+        while (child) {
+            if (child.nodeType == 1) {
+                const childName = child.nodeName;
+                const isArray = isCollection || countByTag[childName] > 1;
+                if (isArray && !json[childName]) json[childName] = [];
                 // In SimpleJson representation, ensure we have proper transformation
                 // of text and CDATA nodes. For instance, the following
                 //  <workflow><desc>Hello</desc></workflow>
@@ -434,12 +443,12 @@ class DomUtil {
                 // from the schema, we cannot know if <desc></desc> should be
                 // transformed into "$desc": "" or into "desc": {}
                 const text = this._getTextIfTextNode(child);
-                if (text !== null && flavor == "SimpleJson") {
+                if (!isArray && text !== null && flavor == "SimpleJson") {
                     json[`$${childName}`] = text;
                 }
                 else {
                     const jsonChild = flavor == "BadgerFish" ? new BadgerFishObject() : {};
-                    this._toJSON(child, jsonChild, flavor);
+                    this._toJSON(child, jsonChild, flavor, json, isArray);
                     if (isArray) 
                         json[childName].push(jsonChild);
                     else
@@ -457,6 +466,46 @@ class DomUtil {
             }
             child = child.nextSibling;
         }
+
+        // Proceed with text nodes in SimpleJson format. 
+        if (flavor === "SimpleJson") {
+            var text = "";
+            child = xml.firstChild;
+            while (child) {
+                if (child.nodeType === 3) { // text 
+                    var nodeText = child.nodeValue;
+                    // Whitespace trimming rule: always trim for the root node, and trim for non-root nodes
+                    // which actually have children elements
+                    // Never trim CDATA nodes (nodeType 4)
+                    if (!parentJson || hasChildElements)
+                        nodeText = nodeText.trim(); 
+                    if (nodeText) text = text + nodeText;
+                }    
+                else if (child.nodeType === 4) { // CDATA    
+                    const cdataText = child.nodeValue;
+                    if (cdataText) text = text + cdataText;
+                }    
+                child = child.nextSibling;
+            }
+            if (text) {
+                json.$ = text;
+            }
+        }
+
+        // Finally proceed with attributes. They are processed last so that we get a chance to prefix
+        // the attribute name with "@" in SimpleJson format if there's already an element with the
+        // same name
+        if (xml.hasAttributes()) {
+            const attributes = xml.attributes;
+            for (var i=0; i<attributes.length; i++) {
+                const att = attributes[i];
+                var attName = (flavor == "BadgerFish" ? "@" : "") + att.name;
+                if (json[attName] !== undefined && flavor === "SimpleJson")
+                    // There's already an element with the same name as the attribute
+                    attName = "@" + attName;
+                json[attName] = att.value;
+            }
+        }
     }
 
     /**

package/src/index.js

@@ -112,15 +112,15 @@ class SDK {
      * There are 2 alternate signatures for this function
      * <ul>
      * <li> the first one takes one single parameter which is a string and returns the escaped, quoted string
-     * <li> the second one takes 2 array of strings and is called when using the function in tagged string litterals. The first array is the constant parts
-     *   of the string litteral, and the second array contains the variable parts. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
+     * <li> the second one takes 2 array of strings and is called when using the function in tagged string literals. The first array is the constant parts
+     *   of the string literal, and the second array contains the variable parts. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals
      * </ul>
      * <p>
-     * The function can be used in a tagged string litterals like this: "var expr = escapeXtk`@name=${hello}`"
+     * The function can be used in a tagged string literals like this: "var expr = escapeXtk`@name=${hello}`"
      * <p>
      * @memberof Campaign
-     * @param {string|string[]} p1 is the text to escape. If the text is null or undefined, it will be handled as an empty string. when using the escapeXtk for a tagged string litteral, this parameter is the array of constant values in the template.
-     * @param {undefined|string[]} p2 when using the escapeXtk for a tagged string litteral, this parameter is the array of expression values in the template.
+     * @param {string|string[]} p1 is the text to escape. If the text is null or undefined, it will be handled as an empty string. when using the escapeXtk for a tagged string literal, this parameter is the array of constant values in the template.
+     * @param {undefined|string[]} p2 when using the escapeXtk for a tagged string literal, this parameter is the array of expression values in the template.
      * @returns {string} the escaped and quoted (simple quotes) text.
      * 
      * @example
@@ -138,7 +138,7 @@ class SDK {
             return "'" + String(p1).replace(/\\/g, "\\\\").replace(/'/g,  "\\'") + "'";
         }
 
-        // Second syntax: for use in tagged template litterals
+        // Second syntax: for use in tagged template literals
         // instead of writing:  { expr: "@name = " + escapeXtk(userName) }
         // you write { expr: escapeXtk`@name = {userName}` }
         if (p1.length == 0) return "''";

package/src/soap.js

@@ -85,7 +85,7 @@ const NS_XSD = "http://www.w3.org/2001/XMLSchema";
 class SoapMethodCall {
     
     constructor(transport, urn, methodName, sessionToken, securityToken, userAgentString, pushDownOptions, extraHttpHeaders) {
-        this.request = undefined;       // The HTTP request (object litteral passed to the transport layer)
+        this.request = undefined;       // The HTTP request (object literal passed to the transport layer)
         this.requestOptions = undefined;
         this.response = undefined;      // The HTTP response object (in case of success)
 

package/src/transport.js

@@ -114,7 +114,6 @@ if (!Util.isBrowser()) {
         method: options.method,
         headers: headers,
         body: options.data,
-        credentials: options.credentials || 'same-origin'
     });
 
     const p = fetch(r).then(async (response) => {

package/src/util.js

@@ -55,7 +55,7 @@ class Util {
     // JavaScript arrays are objects
     if (typeof obj != "object") return false;
     // They also have a length property. But checking the length is not enough
-    // since, it can also be an object litteral with a "length" property. Campaign
+    // since, it can also be an object literal with a "length" property. Campaign
     // schema attributes typically have a "length" attribute and are not arrays
     if (obj.length === undefined || obj.length === null) return false;
     // So check for a "push" function

package/test/client.test.js

@@ -40,14 +40,14 @@ describe('ACC Client', function () {
         it('Create client with invalid parameters', () => {
             // No 4th parameter should be ok
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"))).not.toBeFalsy();
-            // Object litteral is ok too
+            // Object literal is ok too
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"), {})).not.toBeFalsy();
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"), { representation: "BadgerFish" })).not.toBeFalsy();
             expect(new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin"), { dummy: 1 })).not.toBeFalsy();
             // Boolean is not ok
-            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", true)); }).toThrow("An object litteral is expected");
-            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", false)); }).toThrow("An object litteral is expected");
-            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", "BadgerFish")); }).toThrow("An object litteral is expected");
+            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", true)); }).toThrow("An object literal is expected");
+            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", false)); }).toThrow("An object literal is expected");
+            expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", "BadgerFish")); }).toThrow("An object literal is expected");
             // Invalid representation is not ok
             expect(() => { new Client(sdk, ConnectionParameters.ofUserAndPassword("http://acc-sdk:8080", "admin", "admin", { representation: "Hello" })); }).toThrow("Invalid representation");
         });
@@ -2614,7 +2614,7 @@ describe('ACC Client', function () {
         </extAccount-collection>`);
         });
 
-        it("Should force an json representation", async () => {
+        it("Should force a json representation", async () => {
             const client = await Mock.makeClient();
             client._transport.mockReturnValueOnce(Mock.LOGON_RESPONSE);
             await client.NLWS.xtkSession.logon();
@@ -2633,7 +2633,7 @@ describe('ACC Client', function () {
             const query = client.NLWS.json.xtkQueryDef.create(queryDef);
             const result = await query.executeQuery();
             const json = JSON.stringify(result);
-            expect(json).toBe('{"#text":[],"extAccount":[{"id":"1816","name":"defaultPopAccount"},{"id":"1818","name":"defaultOther"},{"id":"1849","name":"billingReport"},{"id":"12070","name":"TST_EXT_ACCOUNT_POSTGRESQL"},{"id":"1817","name":"defaultEmailBulk"},{"id":"2087","name":"ffda"},{"id":"2088","name":"defaultEmailMid"}]}');
+            expect(json).toBe('{"extAccount":[{"id":"1816","name":"defaultPopAccount"},{"id":"1818","name":"defaultOther"},{"id":"1849","name":"billingReport"},{"id":"12070","name":"TST_EXT_ACCOUNT_POSTGRESQL"},{"id":"1817","name":"defaultEmailBulk"},{"id":"2087","name":"ffda"},{"id":"2088","name":"defaultEmailMid"}]}');
         });
     });
 
@@ -3252,8 +3252,10 @@ describe('ACC Client', function () {
                     url: expect.any(String),
                     method: 'POST',
                     processData: false,
-                    credentials: 'include',
-                    headers: expect.anything(),
+                    headers: expect.objectContaining({
+                        'X-Security-Token': expect.any(String),
+                        'X-Session-Token': expect.any(String),
+                    }),
                 })
             );
 
@@ -3514,6 +3516,18 @@ describe('ACC Client', function () {
                 schema: "nms:delivery",
                 formData: {ctx: {}}
             });
+            expect(client._transport).toHaveBeenLastCalledWith(
+                expect.objectContaining({
+                    data: expect.anything(),
+                    url: expect.any(String),
+                    method: 'POST',
+                    headers: expect.objectContaining({
+                        'X-Security-Token': expect.any(String),
+                        'X-Session-Token': expect.any(String),
+                        "Content-Type": "application/x-www-form-urlencoded",
+                    }),
+                })
+            );
             expect(report._reportContext).toBe("throughput");
             expect(report._selection).toBe("12133");
             expect(report.vars.$period).toBe("604800");

package/test/domUtil.test.js

@@ -144,17 +144,19 @@ describe('DomUtil', function() {
             return DomUtil.toXMLString(xml);
         }
 
-        assert.strictEqual(fromJSON({}), '<root/>');
-        assert.strictEqual(fromJSON({ "a":2, "b":"zz", "c": true }), '<root a="2" b="zz" c="true"/>');
-        assert.strictEqual(fromJSON({ "a":{ x:3 } }), '<root><a x="3"/></root>');
-        assert.strictEqual(fromJSON({ "$": "Hello" }), '<root>Hello</root>');
-        assert.strictEqual(fromJSON({ "$a": "Hello" }), '<root><a>Hello</a></root>');
-        assert.strictEqual(fromJSON({ a: { "$": "Hello" } }), '<root><a>Hello</a></root>');
-        assert.strictEqual(fromJSON({ a: "World", "$a": "Hello" }), '<root a="World"><a>Hello</a></root>');
-        assert.strictEqual(fromJSON({ "a": [ { "i":1 }, { "i": 2 } ] }), '<root><a i="1"/><a i="2"/></root>');
-        assert.strictEqual(fromJSON({ "a": [ ] }), '<root/>');
-        assert.strictEqual(fromJSON({ "a": null }), '<root/>');
-        assert.strictEqual(fromJSON({ "a": undefined }), '<root/>');
+        it("Should convert from JSON to XML", () => {
+            assert.strictEqual(fromJSON({}), '<root/>');
+            assert.strictEqual(fromJSON({ "a":2, "b":"zz", "c": true }), '<root a="2" b="zz" c="true"/>');
+            assert.strictEqual(fromJSON({ "a":{ x:3 } }), '<root><a x="3"/></root>');
+            assert.strictEqual(fromJSON({ "$": "Hello" }), '<root>Hello</root>');
+            assert.strictEqual(fromJSON({ "$a": "Hello" }), '<root><a>Hello</a></root>');
+            assert.strictEqual(fromJSON({ a: { "$": "Hello" } }), '<root><a>Hello</a></root>');
+            assert.strictEqual(fromJSON({ a: "World", "$a": "Hello" }), '<root a="World"><a>Hello</a></root>');
+            assert.strictEqual(fromJSON({ "a": [ { "i":1 }, { "i": 2 } ] }), '<root><a i="1"/><a i="2"/></root>');
+            assert.strictEqual(fromJSON({ "a": [ ] }), '<root/>');
+            assert.strictEqual(fromJSON({ "a": null }), '<root/>');
+            assert.strictEqual(fromJSON({ "a": undefined }), '<root/>');
+        });
     });
 
     describe('fromJSON (default)', function() {
@@ -164,17 +166,37 @@ describe('DomUtil', function() {
             return DomUtil.toXMLString(xml);
         }
 
-        assert.strictEqual(fromJSON({}), '<root/>');
-        assert.strictEqual(fromJSON({ "a":2, "b":"zz", "c": true }), '<root a="2" b="zz" c="true"/>');
-        assert.strictEqual(fromJSON({ "a":{ x:3 } }), '<root><a x="3"/></root>');
-        assert.strictEqual(fromJSON({ "$": "Hello" }), '<root>Hello</root>');
-        assert.strictEqual(fromJSON({ "$a": "Hello" }), '<root><a>Hello</a></root>');
-        assert.strictEqual(fromJSON({ a: { "$": "Hello" } }), '<root><a>Hello</a></root>');
-        assert.strictEqual(fromJSON({ a: "World", "$a": "Hello" }), '<root a="World"><a>Hello</a></root>');
-        assert.strictEqual(fromJSON({ "a": [ { "i":1 }, { "i": 2 } ] }), '<root><a i="1"/><a i="2"/></root>');
-        assert.strictEqual(fromJSON({ "a": [ ] }), '<root/>');
-        assert.strictEqual(fromJSON({ "a": null }), '<root/>');
-        assert.strictEqual(fromJSON({ "a": undefined }), '<root/>');
+        it("Should convert from JSON to XML", () => {
+            assert.strictEqual(fromJSON({}), '<root/>');
+            assert.strictEqual(fromJSON({ "a":2, "b":"zz", "c": true }), '<root a="2" b="zz" c="true"/>');
+            assert.strictEqual(fromJSON({ "a":{ x:3 } }), '<root><a x="3"/></root>');
+            assert.strictEqual(fromJSON({ "$": "Hello" }), '<root>Hello</root>');
+            assert.strictEqual(fromJSON({ "$a": "Hello" }), '<root><a>Hello</a></root>');
+            assert.strictEqual(fromJSON({ a: { "$": "Hello" } }), '<root><a>Hello</a></root>');
+            assert.strictEqual(fromJSON({ a: "World", "$a": "Hello" }), '<root a="World"><a>Hello</a></root>');
+            assert.strictEqual(fromJSON({ "a": [ { "i":1 }, { "i": 2 } ] }), '<root><a i="1"/><a i="2"/></root>');
+            assert.strictEqual(fromJSON({ "a": [ ] }), '<root/>');
+            assert.strictEqual(fromJSON({ "a": null }), '<root/>');
+            assert.strictEqual(fromJSON({ "a": undefined }), '<root/>');
+        });
+    });
+
+    describe('fromJSON (advanced)', function() {
+        function fromJSON(json) {
+            var xml = DomUtil.fromJSON("root", json);
+            return DomUtil.toXMLString(xml);
+        }
+
+        it("Should handle fixes made in version 1.1.3", () => {
+            expect(fromJSON({ $: "Hello" })).toBe("<root>Hello</root>");
+            expect(fromJSON({ "$delivery": "Hello" })).toBe("<root><delivery>Hello</delivery></root>");
+            expect(fromJSON({ "delivery": { $: "Hello" } })).toBe("<root><delivery>Hello</delivery></root>");
+            //expect(fromJSON({ "$delivery": "World", "delivery": { $: "Hello" } })).toBe("<root><delivery>Hello</delivery></root>");
+            expect(fromJSON({delivery: { "transaction": "0", "$": "0" }})).toBe('<root><delivery transaction="0">0</delivery></root>');            
+            expect(fromJSON({delivery: { "$": "Hello", child: { name: "world" } }})).toBe('<root><delivery>Hello<child name="world"/></delivery></root>');
+            expect(fromJSON({delivery: { "$": "Hello", child: { name: "world" } }})).toBe('<root><delivery>Hello<child name="world"/></delivery></root>');
+            expect(fromJSON({ delivery: { $: "HelloWorld", child:{} } })).toBe('<root><delivery>HelloWorld<child/></delivery></root>');
+        });
     });
 
     describe('toJSON (SimpleJson)', function() {
@@ -185,20 +207,21 @@ describe('DomUtil', function() {
             return json;
         }
 
-        assert.deepStrictEqual(toJSON('<root/>'), {});
-        assert.deepStrictEqual(toJSON('<root a="1"/>'), { a:"1" });
-        assert.deepStrictEqual(toJSON('<root a="1" b="2"/>'), { a:"1", b:"2" });
-        assert.deepStrictEqual(toJSON('<root><a/></root>'), { a:{} });
-        assert.deepStrictEqual(toJSON('<root><a/><a/></root>'), { a:[{},{}] });
+        it("Should convert XML to SimpleJSON", () => {
+            assert.deepStrictEqual(toJSON('<root/>'), {});
+            assert.deepStrictEqual(toJSON('<root a="1"/>'), { a:"1" });
+            assert.deepStrictEqual(toJSON('<root a="1" b="2"/>'), { a:"1", b:"2" });
+            assert.deepStrictEqual(toJSON('<root><a/></root>'), { a:{} });
+            assert.deepStrictEqual(toJSON('<root><a/><a/></root>'), { a:[{},{}] });
+        });
     });
 
     describe('fromJSON (invalid flavor)', function() {
-        try {
-            DomUtil.fromJSON("root", {}, "InvalidFlavor");
-            assert.fail("Should have failed");
-        } catch(ex) {
-            assert.ok(true);
-        }
+        it("Should fail", () => {
+            expect(() => {
+                DomUtil.fromJSON("root", {}, "InvalidFlavor");
+            }).toThrow();
+        });
     });
 
     describe('toJson (errors)', function() {
@@ -217,6 +240,233 @@ describe('DomUtil', function() {
         
     });
     
+    describe('toJson (SimpleJson, advanced)', function() {
+        function toJSON(xml) {
+            xml = DomUtil.parse(xml);
+            var json = DomUtil.toJSON(xml, "SimpleJson");
+            return json;
+        }
+
+        it("Should handle elements containing both text and other elements", () => {
+            expect(toJSON('<root>Hello</root>')).toEqual({ $: "Hello" });
+            expect(toJSON('<ctx><delivery>Hello</delivery></ctx>')).toEqual({ "$delivery": "Hello" });
+            expect(toJSON('<delivery transaction="0">0</delivery>')).toEqual({ "transaction": "0", "$": "0" });
+            expect(toJSON('<ctx><delivery transaction="0">0</delivery></ctx>')).toEqual({delivery: { "transaction": "0", "$": "0" }});
+            expect(toJSON('<ctx><delivery>Hello<child name="world"/></delivery></ctx>')).toEqual({delivery: { "$": "Hello", child: { name: "world" } }});
+            expect(toJSON('<ctx><delivery><child name="world"/>Hello</delivery></ctx>')).toEqual({delivery: { "$": "Hello", child: { name: "world" } }});
+            expect(toJSON('<root><delivery>Hello<child/>World</delivery></root>')).toEqual({ delivery: { $: "HelloWorld", child:{} } });
+        });
+
+        describe("Should handle insignificant whitespaces", () => {
+            it("Should not remove whitespace for element which does not have any children", () => {
+                expect(toJSON('<root><delivery> \nHello </delivery></root>')).toEqual({ $delivery: " \nHello " });
+            });
+            it("Should remove whitespace for root element even if it does not have any children. Because in SimpleJson we consider that root always has children", () => {
+                expect(toJSON('<root>\n</root>')).toEqual({ });
+                expect(toJSON('<root> \nHello </root>')).toEqual({ $: "Hello" });
+                expect(toJSON('<root> \nHello <delivery/></root>')).toEqual({ $: "Hello", delivery: {} });
+                expect(toJSON('<root> \nHello<delivery/> </root>')).toEqual({ $: "Hello", delivery: {} });
+            });
+            it("Should never remove whitespace in the middle of text", () => {
+                expect(toJSON('<root>Hello World</root>')).toEqual({ $: "Hello World" });
+                expect(toJSON('<root><delivery>Hello World</delivery></root>')).toEqual({ $delivery: "Hello World" });
+                expect(toJSON('<root><delivery>   Hello World </delivery></root>')).toEqual({ $delivery: "   Hello World " });
+                expect(toJSON('<root><delivery>   Hello <child/>World </delivery></root>')).toEqual({ delivery: { $: "HelloWorld", child:{} } });
+                expect(toJSON('<root><delivery>   Hello Cruel W<child/>orld </delivery></root>')).toEqual({ delivery: { $: "Hello Cruel World", child:{} } });
+            });
+
+            it("Should remove insignificant spaces", () => {
+                expect(toJSON('<ctx>\n  <delivery>\n    <target x="2"/>\n  </delivery>\n</ctx>')).toEqual({delivery: { target: { x:"2"} }});    
+            });
+
+            it("Should handle collections", () => {
+                expect(toJSON('<test-collection>\n  <test a="1"></test>\n</test-collection>')).toEqual({test: [ { a:"1" }] });
+                expect(toJSON('<test-collection>\n  <test a="1"></test>\n  <test a="2"></test>\n</test-collection>')).toEqual({test: [ { a:"1" }, { a:"2" }] });
+            });
+
+            it("Should handle collections of text elements", () => {
+                expect(toJSON('<test-collection>\n  <test>One</test>\n</test-collection>')).toEqual({test: [ { $:"One" }] });
+                expect(toJSON('<test-collection>\n  <test>One</test>\n  <test>Two</test>\n</test-collection>')).toEqual({test: [ { $:"One" }, { $:"Two" }] });
+                expect(toJSON('<array>\n  <test>One</test>\n  <test>Two</test>\n</array>')).toEqual({test: [ { $:"One" }, { $:"Two" }] });
+            });
+
+            it("Should never remove whitespaces of CDATA nodes", () => {
+                expect(toJSON('<root><![CDATA[]]></root>')).toEqual({});
+                expect(toJSON('<root><![CDATA[ Hello\tWorld\n  ]]></root>')).toEqual({ $: " Hello\tWorld\n  "});
+                expect(toJSON('<root><![CDATA[ Hello\t]]><![CDATA[World\n  ]]></root>')).toEqual({ $: " Hello\tWorld\n  "});
+            });
+
+            it("Should not handle whitespaces if element containing text has only attributes", () => {
+                // Whitespaces are always removed for the root node
+                expect(toJSON('<delivery transaction="0"> Hello World </delivery>')).toEqual({ "transaction": "0", "$": "Hello World" });
+                // But not for child nodes
+                expect(toJSON('<root><delivery transaction="0"> Hello World </delivery></root>')).toEqual({ delivery: { "transaction": "0", "$": " Hello World " } });
+            });
+        });
+
+        describe("Real payloads", () => {
+            it("Should convert report data payload", () => {
+                const xml = `<ctx lang="en" date="2022-11-18T08:04:06Z" _target="web" webApp-id="1583" _context="selection" _reportContext="deliverySending" _schema="nms:delivery" _hasFilter="false" _selection="12133" _folderModel="nmsDelivery" _folderLinkId="@folder-id" _folderLink="folder" activityHist="@r2rp0BOIZulQ3PcAaXVCr+9of9KxMPqM4MWmTTydhh4/qMVzTGmcRevNzHnoPS0WHvHKH084KIWom6NaVlzR1vCXv47bq3m/dfT3j7MQDSyDwb0rPU/4rD08CeDN3xqR6GazBmh+Lmz+ugo85WCwAaCDUYEJtG/EcqCOO0G+PRtjHlrNOhSrDSxanl4pxonQ4DhDTejA5VjSopu7pvV8U32e5k+fFuk/vvaOMHUP2Zk+VNuMnEytIExnbstFDepeSRDEMuIgmHWuENglhtcdfH3suIcibmqFyBF6Xupcqp2LlicJFFkXHXuM2LgUC7BTGsqMsN4HhNSs6NzW8ZhMPA==">
+                <userInfo datakitInDatabase="true" homeDir="" instanceLocale="en-US" locale="en-US" login="internal" loginCS="Internal account" loginId="0" noConsoleCnx="false" orgUnitId="0" theme="" timezone="Europe/Paris" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns="urn:xtk:session" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>
+                <timezone current="Europe/Paris" changed="false"/>
+                <_contextFilter>
+                  <where>
+                    <condition enabledIf="$(@_context) = 'selection' and $(@_hasFilter) = false" expr="@id = $noescaping(@_selection)"/>
+                    <condition enabledIf="$(@_context) = 'selection' and $(@_hasFilter) and $(@_locationName) != 'descriptiveAnalysis'" expr="@id" setOperator="IN" subQuery="$(whereCond)"/>
+                  </where>
+                </_contextFilter>
+                <activityHistory>
+                  <activity name="page" type="page"/>
+                  <activity name="query2" type="query"/>
+                  <activity name="script2" type="script"/>
+                  <activity name="query" type="query"/>
+                  <activity name="start" type="start"/>
+                </activityHistory>
+                <data>
+                  <query>
+                    <delivery amount="0" article="0" contactDate="" error="0" estimatedRecipientOpen="0" estimatedTotalRecipientOpen="0" forward="0" label="" mirrorPage="0" newQuarantine="0" optOut="0" personClick="0" recipientClick="0" reject="0" success="0" toDeliver="0" totalRecipientClick="0" totalTarget="0" totalWebPage="0" transaction="0">0</delivery>
+                  </query>
+                </data>
+                <vars>
+                  <operator>0</operator>
+                </vars>
+                <title>Delivery:</title>
+                <query2/>
+                <chart_page_123722795831>
+                  <data>&lt;data/&gt;</data>
+                  <config>&lt;graphConfig accumulate="false" autoScale="true" autoStretch="true" computePercent="false" displayEmptySamples="false" filledOpacity="50" innerPieRadius="0" perspective="true" renderType="pie" reverseSeries="false" reverseStacking="false" showLabels="0" sortMode="2" zoomOnWheel="true"&gt;&lt;onclick action="url" enabledWhenHistory="false" target="_blank"/&gt;&lt;legend layout="right" visible="true"/&gt;&lt;series aggregate="sum" label="" renderGroup="layered" xpath="/dlvExclusion" xpathIndex="@label" xpathValue="@count"/&gt;&lt;/graphConfig&gt;</config>
+                </chart_page_123722795831>
+              </ctx>`;
+                expect(toJSON(xml)).toEqual(
+                    {
+                        userInfo: {
+                          datakitInDatabase: "true",
+                          homeDir: "",
+                          instanceLocale: "en-US",
+                          locale: "en-US",
+                          login: "internal",
+                          loginCS: "Internal account",
+                          loginId: "0",
+                          noConsoleCnx: "false",
+                          orgUnitId: "0",
+                          theme: "",
+                          timezone: "Europe/Paris",
+                          "xmlns:SOAP-ENV": "http://schemas.xmlsoap.org/soap/envelope/",
+                          "xmlns:ns": "urn:xtk:session",
+                          "xmlns:xsd": "http://www.w3.org/2001/XMLSchema",
+                          "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                        },
+                        timezone: {
+                          current: "Europe/Paris",
+                          changed: "false",
+                        },
+                        _contextFilter: {
+                          where: {
+                            condition: [
+                              {
+                                enabledIf: "$(@_context) = 'selection' and $(@_hasFilter) = false",
+                                expr: "@id = $noescaping(@_selection)",
+                              },
+                              {
+                                enabledIf: "$(@_context) = 'selection' and $(@_hasFilter) and $(@_locationName) != 'descriptiveAnalysis'",
+                                expr: "@id",
+                                setOperator: "IN",
+                                subQuery: "$(whereCond)",
+                              },
+                            ],
+                          },
+                        },
+                        activityHistory: {
+                          activity: [
+                            {
+                              name: "page",
+                              type: "page",
+                            },
+                            {
+                              name: "query2",
+                              type: "query",
+                            },
+                            {
+                              name: "script2",
+                              type: "script",
+                            },
+                            {
+                              name: "query",
+                              type: "query",
+                            },
+                            {
+                              name: "start",
+                              type: "start",
+                            },
+                          ],
+                        },
+                        data: {
+                          query: {
+                            delivery: {
+                              $: "0",
+                              amount: "0",
+                              article: "0",
+                              contactDate: "",
+                              error: "0",
+                              estimatedRecipientOpen: "0",
+                              estimatedTotalRecipientOpen: "0",
+                              forward: "0",
+                              label: "",
+                              mirrorPage: "0",
+                              newQuarantine: "0",
+                              optOut: "0",
+                              personClick: "0",
+                              recipientClick: "0",
+                              reject: "0",
+                              success: "0",
+                              toDeliver: "0",
+                              totalRecipientClick: "0",
+                              totalTarget: "0",
+                              totalWebPage: "0",
+                              transaction: "0",
+                            },
+                          },
+                        },
+                        vars: {
+                          $operator: "0",
+                        },
+                        $title: "Delivery:",
+                        query2: {
+                        },
+                        chart_page_123722795831: {
+                          $data: "<data/>",
+                          $config: "<graphConfig accumulate=\"false\" autoScale=\"true\" autoStretch=\"true\" computePercent=\"false\" displayEmptySamples=\"false\" filledOpacity=\"50\" innerPieRadius=\"0\" perspective=\"true\" renderType=\"pie\" reverseSeries=\"false\" reverseStacking=\"false\" showLabels=\"0\" sortMode=\"2\" zoomOnWheel=\"true\"><onclick action=\"url\" enabledWhenHistory=\"false\" target=\"_blank\"/><legend layout=\"right\" visible=\"true\"/><series aggregate=\"sum\" label=\"\" renderGroup=\"layered\" xpath=\"/dlvExclusion\" xpathIndex=\"@label\" xpathValue=\"@count\"/></graphConfig>",
+                        },
+                        lang: "en",
+                        date: "2022-11-18T08:04:06Z",
+                        _target: "web",
+                        "webApp-id": "1583",
+                        _context: "selection",
+                        _reportContext: "deliverySending",
+                        _schema: "nms:delivery",
+                        _hasFilter: "false",
+                        _selection: "12133",
+                        _folderModel: "nmsDelivery",
+                        _folderLinkId: "@folder-id",
+                        _folderLink: "folder",
+                        activityHist: "@r2rp0BOIZulQ3PcAaXVCr+9of9KxMPqM4MWmTTydhh4/qMVzTGmcRevNzHnoPS0WHvHKH084KIWom6NaVlzR1vCXv47bq3m/dfT3j7MQDSyDwb0rPU/4rD08CeDN3xqR6GazBmh+Lmz+ugo85WCwAaCDUYEJtG/EcqCOO0G+PRtjHlrNOhSrDSxanl4pxonQ4DhDTejA5VjSopu7pvV8U32e5k+fFuk/vvaOMHUP2Zk+VNuMnEytIExnbstFDepeSRDEMuIgmHWuENglhtcdfH3suIcibmqFyBF6Xupcqp2LlicJFFkXHXuM2LgUC7BTGsqMsN4HhNSs6NzW8ZhMPA==",
+                      }
+                );
+            });
+        });
+
+        it("Should support attribute and element with same name", () => {
+            expect(toJSON('<ctx lang="en" timezone="Europe/Paris"><timezone current="Europe/Paris" changed="false"/></ctx>')).toEqual({
+                lang: "en",
+                "@timezone": "Europe/Paris",
+                "timezone": {
+                    current: "Europe/Paris",
+                    changed: "false",
+                }
+            });
+        });
+
+    });
 
     describe('toXMLString', function() {
 

package/test/escape.test.js

@@ -46,9 +46,9 @@ describe('escaping', function() {
             });
         })
 
-        describe('Tagged template litteral', function() {
+        describe('Tagged template literal', function() {
 
-            it("Should escape in template litteral", () => {
+            it("Should escape in template literal", () => {
                 expect(sdk.escapeXtk`Hello world`).toBe("Hello world");
                 expect(sdk.escapeXtk`Hello 'world'`).toBe("Hello 'world'");     // only variables are escaped
 
@@ -77,7 +77,7 @@ describe('escaping', function() {
             expect(sdk.escapeXtk`@name=${"Rock 'n' Roll"}`).toBe("@name='Rock \\'n\\' Roll'");
         });
 
-        describe('QueryDef & template litteral', () => {
+        describe('QueryDef & template literal', () => {
             
         })
 

package/test/util.test.js

@@ -17,8 +17,8 @@ governing permissions and limitations under the License.
  * 
  *********************************************************************************/
 
- const { Util, ArrayMap } = require('../src/util.js');
- const { SafeStorage, Cache } = require('../src/cache.js');
+const { Util, ArrayMap } = require('../src/util.js');
+const { SafeStorage, Cache } = require('../src/cache.js');
 
 
 describe('Util', function() {
@@ -102,7 +102,6 @@ describe('Util', function() {
         })
     })
 
-
     describe("Safe storage", () => {
       it("Should support undefined delegate", () => {
           const storage = new SafeStorage();