@adobe/acc-js-sdk 1.1.42 → 1.1.44

package/docs/application.html

@@ -291,6 +291,8 @@ const root = await node.linkTarget();
     <tr><td><b>belongsTo</b></td><td>For attribute and elements, indicates the schema id in which they were defined. Since version 1.1.10 of the SDK</td></tr>
     <tr><td><b>default</b></td><td>Default value if any. Can be an array for collections. Since version 1.1.24 of the SDK</td></tr>
     <tr><td><b>translatedDefault</b></td><td>Default value if any. Since version 1.1.24 of the SDK</td></tr>
+    <tr><td><b>ordered</b></td><td>If children are ordered</td></tr>
+    <tr><td><b>doesNotSupportDiff</b></td><td>If returning the whole node when comparing difference</td></tr>
   </tbody>
 </table>
 

package/docs/changeLog.html

@@ -2,6 +2,23 @@
 layout: page
 title: Change Log
 ---
+<section class="changelog"><h1>Version 1.1.44</h1>
+  <h2>2024/01/02</h2>
+  <li>
+    Add the "ordered" and "doesNotSupportDiff" attributes to the nodes in the application object
+  </li>
+</section>
+
+
+<section class="changelog"><h1>Version 1.1.43</h1>
+  <h2>2023/12/21</h2>
+  <li>
+    Do not throw an error in case of duplicate enumeration value. Use the last one instead. This introduces a small behavior change
+    because this was causing an exception before.
+  </li>
+</section>
+
+
 <section class="changelog"><h1>Version 1.1.42</h1>
   <h2>2023/12/20</h2>
   <li>

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@adobe/acc-js-sdk",
-  "version": "1.1.42",
+  "version": "1.1.44",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@adobe/acc-js-sdk",
-      "version": "1.1.42",
+      "version": "1.1.44",
       "license": "ISC",
       "dependencies": {
         "axios": "^1.2.1",

package/package.json

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

package/src/application.js

@@ -386,6 +386,12 @@ class XtkSchemaNode {
          */
         this.unbound = EntityAccessor.getAttributeAsBoolean(xml, "unbound");
 
+        /**
+         * If children are ordered
+         * @type {boolean}
+         */
+        this.ordered = EntityAccessor.getAttributeAsBoolean(xml, "ordered");
+
         /**
          * The expression controlling the visibility of the current node
          * @type {string}
@@ -410,6 +416,12 @@ class XtkSchemaNode {
          */
         this.isAdvanced = EntityAccessor.getAttributeAsBoolean(xml, "advanced");
 
+        /**
+         * if returning the whole node when camparing difference
+         * @type {boolean}
+         */
+        this.doesNotSupportDiff = EntityAccessor.getAttributeAsBoolean(xml, "doesNotSupportDiff");
+
         /**
          * Children of the node. This is a object whose key are the names of the children nodes (without the "@"
          * character for attributes) 

package/src/util.js

@@ -196,13 +196,17 @@ class ArrayMap {
 
   _push(key, value, withoutIndexing) {
       let isNumKey = false;
+      let updateIndex = -1;
+
       if (key) {
         // reserved keyworkds
         const isReserved = key === "_items" || key === "length" || key === "_push" || key === "forEach" || key === "map" || key === "_map" || key === "get" || key === "find" || key === "flatMap" || key === "filter";
 
         // already a child with the name => there's a problem with the schema
-        if (!isReserved && this[key]) 
-          throw new Error(`Failed to add element '${key}' to ArrayMap. There's already an item with the same name`);
+        // it seems the current behavior is to replace the existing item with the new one
+        if (!isReserved && this[key]) {
+          updateIndex = this._items.indexOf(this[key]);
+        }
 
         // Set key as a enumerable property, so that elements can be accessed by key, 
         // but also iterated on with a for ... in loop
@@ -222,14 +226,19 @@ class ArrayMap {
       if (!withoutIndexing && !isNumKey) {
         // Set the index property so that items can be accessed by array index.
         // However, make it non-enumerable to make sure indexes do not show up in a for .. in loop
-        Object.defineProperty(this, this._items.length, {
+        const numKey = updateIndex == -1 ? this._items.length : updateIndex;
+        Object.defineProperty(this, numKey, {
           value: value,
           writable: false,
           enumerable: false,
+          configurable: true, // Allow to redefine the property later in case there's a duplicate key
         });
       }
       // Add to array and set length
-      this._items.push(value);
+      if (updateIndex == -1)
+        this._items.push(value);
+      else
+        this._items[updateIndex] = value;
       this.length = this._items.length;
   }
 

package/test/application.test.js

@@ -45,13 +45,37 @@ describe('Application', () => {
             });
 
             it("Duplicate root nodes", () => {
-                expect(() => {
-                    var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
-                                                <element name='recipient' label='Recipients'/>
-                                                <element name='recipient' label='Recipients2'/>
-                                            </schema>`);
-                    newSchema(xml);    
-                }).toThrow("Failed to add element 'recipient' to ArrayMap. There's already an item with the same name");
+                var xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                            <element name='recipient' label='Recipients'/>
+                                            <element name='recipient' label='Recipients2'/>
+                                        </schema>`);
+                var schema = newSchema(xml);
+                var root = schema.root;
+                expect(root).toBeTruthy();
+                expect(root.name).toBe("recipient");
+                expect(root.label).toBe("Recipients2");
+            });
+
+            it("Duplicate enumeration value", () => {
+                const xml = DomUtil.parse(`<schema namespace='nms' name='recipient'>
+                                            <enumeration basetype="string" name="AKA">
+                                                <value name="PC" value="1"/>
+                                                <value name="CL2" value="2"/>
+                                                <value name="CL3" value="3"/>
+                                                <value name="Null" value="4"/>
+                                                <value name="Null" value="NULL"/>
+                                            </enumeration>
+                                            <element name='recipient' label='Recipients'/>
+                                        </schema>`);
+                const schema = newSchema(xml);
+                const enumerations = schema.enumerations;
+                const enumeration = enumerations.AKA.values;
+                expect(enumeration.length).toBe(4);
+                expect(enumeration[0].name).toBe("PC");
+                expect(enumeration[1].name).toBe("CL2");
+                expect(enumeration[2].name).toBe("CL3");
+                expect(enumeration[3].name).toBe("Null");
+                expect(enumeration[3].value).toBe("NULL");
             });
 
             it("Should find root node", () => {

package/test/util.test.js

@@ -371,10 +371,26 @@ describe('Util', function() {
             expect(cat).toBe("012");
         });
 
-        it("Should not support adding the same key twice", () => {
+        it("Should support adding the same key twice. The last value overwrites", () => {
             const am = new ArrayMap();
             am._push("hello", "Hello");
-            expect(() => { am._push("hello", "World"); }).toThrow("Failed to add element 'hello' to ArrayMap. There's already an item with the same name");
+            expect(am.length).toBe(1);
+            am._push("hello", "World");
+            expect(am.length).toBe(1);
+            expect(am.get(0)).toBe("World");
+        });
+
+        it("Should support adding the same key twice. The last value overwrites in the middle of the array", () => {
+            const am = new ArrayMap();
+            am._push("hello", "Hello");
+            am._push("cruel", "Cruel");
+            am._push("world", "World");
+            expect(am.length).toBe(3);
+            am._push("cruel", "*cruel*");
+            expect(am.length).toBe(3);
+            expect(am.get(0)).toBe("Hello");
+            expect(am.get(1)).toBe("*cruel*");
+            expect(am.get(2)).toBe("World");
         });
 
         it("Should support missing names", () => {