update: add fcid to unit

Author: VsevolodX

dist/js/subworkflows/subworkflow.js

@@ -294,7 +294,7 @@ class Subworkflow extends BaseSubworkflow {
    */
   addSuffixToFlowchartID(suffix) {
     this._units.forEach(unit => {
-      unit._flowchartId = `${unit._flowchartId}-${suffix}`;
+      unit.setProp("flowchartId", `${unit.flowchartId}-${suffix}`);
     });
     return this;
   }

src/js/subworkflows/subworkflow.js

@@ -354,7 +354,7 @@ export class Subworkflow extends BaseSubworkflow {
      */
     addSuffixToFlowchartID(suffix) {
         this._units.forEach((unit) => {
-            unit._flowchartId = `${unit._flowchartId}-${suffix}`;
+            unit.setProp("flowchartId", `${unit.flowchartId}-${suffix}`);
         });
         return this;
     }

tests/js/subworkflow.test.js

@@ -138,60 +138,62 @@ describe("subworkflow addSuffixToFlowchartID", () => {
         });
     });
 
-    it("should create a new subworkflow instance with unique flowchart IDs", () => {
+    it("should append suffix to flowchart IDs", () => {
+        const originalFlowchartId = subworkflow.units[0].flowchartId;
         const uniqueSubworkflow = subworkflow.addSuffixToFlowchartID(1);
 
-        // Should be a different instance
-        expect(uniqueSubworkflow).to.not.equal(subworkflow);
+        // Should return the same instance (mutates in place)
+        expect(uniqueSubworkflow).to.equal(subworkflow);
 
-        // Original subworkflow should be unchanged
-        expect(subworkflow.units[0].flowchartId).to.not.include("-1");
+        // Original subworkflow should be changed (mutated)
+        expect(subworkflow.units[0].flowchartId).to.include("-1");
+        expect(subworkflow.units[0].flowchartId).to.equal(`${originalFlowchartId}-1`);
 
-        // New subworkflow should have suffixed IDs
-        uniqueSubworkflow.units.forEach((unit) => {
+        // All units should have suffixed IDs
+        subworkflow.units.forEach((unit) => {
             expect(unit.flowchartId).to.match(/-1$/);
         });
     });
 
-    it("should update next references correctly", () => {
-        const uniqueSubworkflow = subworkflow.addSuffixToFlowchartID(2);
+    it("should append suffix to flowchart IDs when called multiple times", () => {
+        subworkflow.addSuffixToFlowchartID(2);
 
-        uniqueSubworkflow.units.forEach((unit) => {
-            if (unit.next) {
-                // next should also have the suffix
-                expect(unit.next).to.match(/-2$/);
+        subworkflow.units.forEach((unit) => {
+            expect(unit.flowchartId).to.match(/-2$/);
+        });
 
-                // next should point to an existing unit
-                const nextUnit = uniqueSubworkflow.units.find((u) => u.flowchartId === unit.next);
-                expect(nextUnit).to.not.be.undefined;
-            }
+        // Calling again should append another suffix
+        subworkflow.addSuffixToFlowchartID(3);
+        subworkflow.units.forEach((unit) => {
+            expect(unit.flowchartId).to.match(/-2-3$/);
         });
     });
 
     it("should handle custom suffix values", () => {
-        const uniqueSubworkflow1 = subworkflow.addSuffixToFlowchartID("custom");
-        const uniqueSubworkflow2 = subworkflow.addSuffixToFlowchartID(42);
+        subworkflow.addSuffixToFlowchartID("custom");
 
-        uniqueSubworkflow1.units.forEach((unit) => {
+        subworkflow.units.forEach((unit) => {
             expect(unit.flowchartId).to.match(/-custom$/);
         });
-
-        uniqueSubworkflow2.units.forEach((unit) => {
-            expect(unit.flowchartId).to.match(/-42$/);
-        });
     });
 
     it("should preserve all unit properties except flowchart IDs", () => {
-        const uniqueSubworkflow = subworkflow.addSuffixToFlowchartID(1);
+        const originalUnitCount = subworkflow.units.length;
+        const originalName = subworkflow.name;
+        const originalAppName = subworkflow.application.name;
+        const originalUnitTypes = subworkflow.units.map((u) => u.type);
+        const originalUnitNames = subworkflow.units.map((u) => u.name);
+
+        subworkflow.addSuffixToFlowchartID(1);
 
-        expect(uniqueSubworkflow.units.length).to.equal(subworkflow.units.length);
-        expect(uniqueSubworkflow.name).to.equal(subworkflow.name);
-        expect(uniqueSubworkflow.application.name).to.equal(subworkflow.application.name);
+        expect(subworkflow.units.length).to.equal(originalUnitCount);
+        expect(subworkflow.name).to.equal(originalName);
+        expect(subworkflow.application.name).to.equal(originalAppName);
 
-        uniqueSubworkflow.units.forEach((unit, index) => {
-            const originalUnit = subworkflow.units[index];
-            expect(unit.type).to.equal(originalUnit.type);
-            expect(unit.name).to.equal(originalUnit.name);
+        subworkflow.units.forEach((unit, index) => {
+            expect(unit.type).to.equal(originalUnitTypes[index]);
+            expect(unit.name).to.equal(originalUnitNames[index]);
+            expect(unit.flowchartId).to.match(/-1$/);
         });
     });
 });