@usertour/helpers 0.0.50 → 0.0.52

package/dist/__tests__/content-helper.test.cjs

@@ -323,25 +323,15 @@ var duplicateData = (data, contentType) => {
   }
   return data;
 };
-var duplicateStep = (step, options) => {
-  var _a;
-  const { id, cvid, createdAt, updatedAt, versionId, trigger, target, data, ...rest } = step;
-  const preserveUndefined = (_a = options == null ? void 0 : options.preserveUndefined) != null ? _a : false;
+var duplicateStep = (step) => {
+  const { id, createdAt, updatedAt, versionId, trigger, target, data, ...rest } = step;
   return {
     ...rest,
-    data: data ? processQuestionElements(data) : preserveUndefined ? data : [],
-    trigger: trigger ? duplicateTriggers(trigger) : preserveUndefined ? trigger : [],
+    data: data ? processQuestionElements(data) : [],
+    trigger: trigger ? duplicateTriggers(trigger) : [],
     target: duplicateTarget(target)
   };
 };
-var duplicateStepWithRename = (originalStep, sequence, existingStepNames) => {
-  const duplicated = duplicateStep(originalStep);
-  return {
-    ...duplicated,
-    name: generateUniqueCopyName(originalStep.name, existingStepNames),
-    sequence
-  };
-};
 
 // src/__tests__/content-helper.test.ts
 jest.mock("../helper", () => ({
@@ -771,6 +761,69 @@ describe("duplicateTriggers", () => {
     expect(result[0].actions).toBeUndefined();
     expect(result[0].conditions).toBeUndefined();
   });
+  test("should handle empty array", () => {
+    const triggers = [];
+    const result = duplicateTriggers(triggers);
+    expect(result).toEqual([]);
+  });
+  test("should handle multiple triggers", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
+        conditions: []
+      },
+      {
+        id: "trigger-2",
+        actions: [],
+        conditions: [{ id: "condition-1", type: "test", operators: "and", data: {} }]
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result).toHaveLength(2);
+    expect(result[0].id).toBe("mock-cuid");
+    expect(result[1].id).toBe("mock-cuid");
+    expect(result[0].actions[0].id).toBe("regenerated-action-1");
+    expect(result[1].conditions[0].id).toBe("regenerated-condition-1");
+  });
+  test("should preserve other trigger properties", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        customType: "click",
+        customSelector: ".button",
+        delay: 1e3,
+        actions: [],
+        conditions: []
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].customType).toBe("click");
+    expect(result[0].customSelector).toBe(".button");
+    expect(result[0].delay).toBe(1e3);
+  });
+  test("should handle triggers with non-array actions", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        actions: "not-an-array",
+        conditions: []
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].actions).toBe("not-an-array");
+  });
+  test("should handle triggers with non-array conditions", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        actions: [],
+        conditions: "not-an-array"
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].conditions).toBe("not-an-array");
+  });
 });
 describe("duplicateTarget", () => {
   test("should return undefined for undefined target", () => {
@@ -803,6 +856,42 @@ describe("duplicateTarget", () => {
     const result = duplicateTarget(target);
     expect(result).toEqual(target);
   });
+  test("should handle target with empty actions array", () => {
+    const target = {
+      selector: ".test",
+      actions: []
+    };
+    const result = duplicateTarget(target);
+    expect(result == null ? void 0 : result.actions).toEqual([]);
+  });
+  test("should handle target with multiple actions", () => {
+    var _a, _b;
+    const target = {
+      selector: ".test",
+      actions: [
+        { id: "action-1", type: "test1", operators: "and", data: {} },
+        { id: "action-2", type: "test2", operators: "or", data: {} }
+      ]
+    };
+    const result = duplicateTarget(target);
+    expect(result == null ? void 0 : result.actions).toHaveLength(2);
+    expect((_a = result == null ? void 0 : result.actions) == null ? void 0 : _a[0].id).toBe("regenerated-action-1");
+    expect((_b = result == null ? void 0 : result.actions) == null ? void 0 : _b[1].id).toBe("regenerated-action-2");
+  });
+  test("should preserve other target properties", () => {
+    var _a;
+    const target = {
+      selectors: [".test-selector"],
+      customPlacement: "bottom",
+      offset: { x: 10, y: 20 },
+      actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+    };
+    const result = duplicateTarget(target);
+    expect(result == null ? void 0 : result.selectors).toEqual([".test-selector"]);
+    expect(result == null ? void 0 : result.customPlacement).toBe("bottom");
+    expect(result == null ? void 0 : result.offset).toEqual({ x: 10, y: 20 });
+    expect((_a = result == null ? void 0 : result.actions) == null ? void 0 : _a[0].id).toBe("regenerated-action-1");
+  });
 });
 describe("duplicateChecklistData", () => {
   test("should return data as-is for null", () => {
@@ -879,6 +968,247 @@ describe("duplicateChecklistData", () => {
     const result = duplicateChecklistData(data);
     expect(result.items[0].onlyShowTaskConditions[0].id).toBe("regenerated-condition-1");
   });
+  test("should process content field with question elements", () => {
+    var _a;
+    const questionElement = {
+      type: import_types4.ContentEditorElementType.NPS,
+      data: { name: "NPS Question", cvid: "old-cvid" }
+    };
+    const data = {
+      content: [
+        {
+          type: "root",
+          children: [
+            {
+              type: "column",
+              children: [
+                {
+                  type: "element",
+                  element: questionElement
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      items: [
+        {
+          id: "item-1",
+          clickedActions: [],
+          completeConditions: [],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    const processedElement = (_a = result.content) == null ? void 0 : _a[0].children[0].children[0].element;
+    expect(processedElement.data.cvid).toBe("mock-cuid");
+  });
+  test("should handle multiple items", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          title: "Task 1",
+          clickedActions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
+          completeConditions: [],
+          onlyShowTaskConditions: []
+        },
+        {
+          id: "item-2",
+          title: "Task 2",
+          clickedActions: [],
+          completeConditions: [{ id: "condition-2", type: "test", operators: "and", data: {} }],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items).toHaveLength(2);
+    expect(result.items[0].id).toBe("mock-uuid");
+    expect(result.items[1].id).toBe("mock-uuid");
+    expect(result.items[0].clickedActions[0].id).toBe("regenerated-action-1");
+    expect(result.items[1].completeConditions[0].id).toBe("regenerated-condition-2");
+  });
+  test("should handle items without conditions arrays", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          title: "Task 1"
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items[0].id).toBe("mock-uuid");
+    expect(result.items[0].clickedActions).toBeUndefined();
+    expect(result.items[0].completeConditions).toBeUndefined();
+    expect(result.items[0].onlyShowTaskConditions).toBeUndefined();
+  });
+  test("should preserve other item properties", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          name: "Task 1",
+          description: "A task description",
+          isCompleted: false,
+          clickedActions: [],
+          completeConditions: [],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items[0].name).toBe("Task 1");
+    expect(result.items[0].description).toBe("A task description");
+    expect(result.items[0].isCompleted).toBe(false);
+  });
+});
+describe("duplicateLauncherData", () => {
+  test("should return data as-is for null", () => {
+    const result = duplicateLauncherData(null);
+    expect(result).toBeNull();
+  });
+  test("should return data as-is for undefined", () => {
+    const result = duplicateLauncherData(void 0);
+    expect(result).toBeUndefined();
+  });
+  test("should return data as-is for non-object", () => {
+    const result = duplicateLauncherData("string");
+    expect(result).toBe("string");
+  });
+  test("should return data as-is for number", () => {
+    const result = duplicateLauncherData(123);
+    expect(result).toBe(123);
+  });
+  test("should regenerate behavior.actions IDs", () => {
+    var _a;
+    const data = {
+      behavior: {
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect((_a = result.behavior) == null ? void 0 : _a.actions[0].id).toBe("regenerated-action-1");
+  });
+  test("should handle behavior without actions", () => {
+    var _a, _b;
+    const data = {
+      behavior: {
+        behaviorType: "click"
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect((_a = result.behavior) == null ? void 0 : _a.behaviorType).toBe("click");
+    expect((_b = result.behavior) == null ? void 0 : _b.actions).toBeUndefined();
+  });
+  test("should handle behavior with non-array actions", () => {
+    var _a;
+    const data = {
+      behavior: {
+        actions: "not-an-array"
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect((_a = result.behavior) == null ? void 0 : _a.actions).toBe("not-an-array");
+  });
+  test("should process tooltip.content with question elements", () => {
+    var _a, _b;
+    const questionElement = {
+      type: import_types4.ContentEditorElementType.NPS,
+      data: { name: "NPS Question", cvid: "old-cvid" }
+    };
+    const data = {
+      tooltip: {
+        content: [
+          {
+            type: "root",
+            children: [
+              {
+                type: "column",
+                children: [
+                  {
+                    type: "element",
+                    element: questionElement
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    };
+    const result = duplicateLauncherData(data);
+    const processedElement = (_b = (_a = result.tooltip) == null ? void 0 : _a.content) == null ? void 0 : _b[0].children[0].children[0].element;
+    expect(processedElement.data.cvid).toBe("mock-cuid");
+  });
+  test("should handle data without behavior", () => {
+    var _a;
+    const data = {
+      tooltip: {
+        content: []
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect(result.behavior).toBeUndefined();
+    expect((_a = result.tooltip) == null ? void 0 : _a.content).toEqual([]);
+  });
+  test("should handle data without tooltip", () => {
+    var _a;
+    const data = {
+      behavior: {
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect(result.tooltip).toBeUndefined();
+    expect((_a = result.behavior) == null ? void 0 : _a.actions[0].id).toBe("regenerated-action-1");
+  });
+  test("should handle both behavior and tooltip", () => {
+    var _a, _b, _c;
+    const questionElement = {
+      type: import_types4.ContentEditorElementType.NPS,
+      data: { name: "NPS Question", cvid: "old-cvid" }
+    };
+    const data = {
+      behavior: {
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+      },
+      tooltip: {
+        content: [
+          {
+            type: "root",
+            children: [
+              {
+                type: "column",
+                children: [
+                  {
+                    type: "element",
+                    element: questionElement
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect((_a = result.behavior) == null ? void 0 : _a.actions[0].id).toBe("regenerated-action-1");
+    const processedElement = (_c = (_b = result.tooltip) == null ? void 0 : _b.content) == null ? void 0 : _c[0].children[0].children[0].element;
+    expect(processedElement.data.cvid).toBe("mock-cuid");
+  });
+  test("should preserve other data properties", () => {
+    const data = {
+      customProperty: "value",
+      behavior: {
+        actions: []
+      }
+    };
+    const result = duplicateLauncherData(data);
+    expect(result.customProperty).toBe("value");
+  });
 });
 describe("duplicateConfig", () => {
   test("should return config as-is for null", () => {
@@ -913,6 +1243,57 @@ describe("duplicateConfig", () => {
     expect(result.autoStartRules).toBeUndefined();
     expect(result.hideRules).toBeUndefined();
   });
+  test("should handle config with both autoStartRules and hideRules", () => {
+    var _a, _b;
+    const config = {
+      autoStartRules: [{ id: "auto-rule-1", type: "test", operators: "and", data: {} }],
+      hideRules: [{ id: "hide-rule-1", type: "test", operators: "and", data: {} }]
+    };
+    const result = duplicateConfig(config);
+    expect((_a = result.autoStartRules) == null ? void 0 : _a[0].id).toBe("regenerated-auto-rule-1");
+    expect((_b = result.hideRules) == null ? void 0 : _b[0].id).toBe("regenerated-hide-rule-1");
+  });
+  test("should handle config with empty rules arrays", () => {
+    const config = {
+      autoStartRules: [],
+      hideRules: []
+    };
+    const result = duplicateConfig(config);
+    expect(result.autoStartRules).toEqual([]);
+    expect(result.hideRules).toEqual([]);
+  });
+  test("should preserve other config properties", () => {
+    const config = {
+      autoStartRules: [{ id: "rule-1", type: "test", operators: "and", data: {} }],
+      frequency: "once",
+      dismissible: true,
+      priority: 100
+    };
+    const result = duplicateConfig(config);
+    expect(result.frequency).toBe("once");
+    expect(result.dismissible).toBe(true);
+    expect(result.priority).toBe(100);
+  });
+  test("should handle config with multiple rules in arrays", () => {
+    var _a, _b, _c, _d;
+    const config = {
+      autoStartRules: [
+        { id: "rule-1", type: "test1", operators: "and", data: {} },
+        { id: "rule-2", type: "test2", operators: "or", data: {} }
+      ],
+      hideRules: [
+        { id: "rule-3", type: "test3", operators: "and", data: {} },
+        { id: "rule-4", type: "test4", operators: "or", data: {} }
+      ]
+    };
+    const result = duplicateConfig(config);
+    expect(result.autoStartRules).toHaveLength(2);
+    expect(result.hideRules).toHaveLength(2);
+    expect((_a = result.autoStartRules) == null ? void 0 : _a[0].id).toBe("regenerated-rule-1");
+    expect((_b = result.autoStartRules) == null ? void 0 : _b[1].id).toBe("regenerated-rule-2");
+    expect((_c = result.hideRules) == null ? void 0 : _c[0].id).toBe("regenerated-rule-3");
+    expect((_d = result.hideRules) == null ? void 0 : _d[1].id).toBe("regenerated-rule-4");
+  });
 });
 describe("duplicateData", () => {
   test("should process checklist data for CHECKLIST content type", () => {
@@ -929,106 +1310,198 @@ describe("duplicateData", () => {
     const result = duplicateData(data, import_types4.ContentDataType.CHECKLIST);
     expect(result.items[0].id).toBe("mock-uuid");
   });
-  test("should return data as-is for non-CHECKLIST content type", () => {
+  test("should process launcher data for LAUNCHER content type", () => {
+    var _a;
+    const data = {
+      behavior: {
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+      }
+    };
+    const result = duplicateData(data, import_types4.ContentDataType.LAUNCHER);
+    expect((_a = result.behavior) == null ? void 0 : _a.actions[0].id).toBe("regenerated-action-1");
+  });
+  test("should return data as-is for FLOW content type", () => {
     const data = { someData: "value" };
     const result = duplicateData(data, "flow");
     expect(result).toEqual(data);
   });
+  test("should return data as-is for unknown content type", () => {
+    const data = { someData: "value" };
+    const result = duplicateData(data, "unknown-type");
+    expect(result).toEqual(data);
+  });
+  test("should return null data as-is", () => {
+    const result = duplicateData(null, import_types4.ContentDataType.CHECKLIST);
+    expect(result).toBeNull();
+  });
+  test("should return undefined data as-is", () => {
+    const result = duplicateData(void 0, import_types4.ContentDataType.LAUNCHER);
+    expect(result).toBeUndefined();
+  });
 });
-describe("duplicateStepWithRename", () => {
-  test("should duplicate the step with new name", () => {
-    const originalStep = {
-      id: "step-1",
-      cvid: "cvid-1",
-      name: "Original Step",
+describe("duplicateStep", () => {
+  test("should remove id, createdAt, updatedAt, versionId fields but preserve cvid", () => {
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
       sequence: 0,
-      trigger: [],
+      createdAt: /* @__PURE__ */ new Date("2024-01-01"),
+      updatedAt: /* @__PURE__ */ new Date("2024-01-02"),
+      versionId: "version-id",
       data: [],
-      target: void 0,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
+      trigger: [],
+      target: void 0
     };
-    const result = duplicateStepWithRename(originalStep, 1);
-    expect(result.name).toBe("Original Step (copy)");
-    expect(result.sequence).toBe(1);
+    const result = duplicateStep(step);
     expect(result).not.toHaveProperty("id");
-    expect(result).not.toHaveProperty("cvid");
+    expect(result).toHaveProperty("cvid");
+    expect(result.cvid).toBe("step-cvid");
     expect(result).not.toHaveProperty("createdAt");
     expect(result).not.toHaveProperty("updatedAt");
+    expect(result).not.toHaveProperty("versionId");
+  });
+  test("should preserve name and sequence", () => {
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
+      sequence: 5,
+      data: [],
+      trigger: [],
+      target: void 0
+    };
+    const result = duplicateStep(step);
+    expect(result.name).toBe("Test Step");
+    expect(result.sequence).toBe(5);
   });
-  test("should generate unique name when existing names provided", () => {
-    const originalStep = {
-      id: "step-1",
-      cvid: "cvid-1",
-      name: "Step",
+  test("should process data field with question elements", () => {
+    var _a;
+    const questionElement = {
+      type: import_types4.ContentEditorElementType.NPS,
+      data: { name: "NPS Question", cvid: "old-cvid" }
+    };
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
       sequence: 0,
+      data: [
+        {
+          type: "root",
+          children: [
+            {
+              type: "column",
+              children: [
+                {
+                  type: "element",
+                  element: questionElement
+                }
+              ]
+            }
+          ]
+        }
+      ],
       trigger: [],
-      data: [],
       target: void 0
     };
-    const result = duplicateStepWithRename(originalStep, 1, ["Step (copy)"]);
-    expect(result.name).toBe("Step (copy 2)");
+    const result = duplicateStep(step);
+    const processedElement = (_a = result.data) == null ? void 0 : _a[0].children[0].children[0].element;
+    expect(processedElement.data.cvid).toBe("mock-cuid");
   });
-  test("should process triggers in step duplicate", () => {
-    var _a;
-    const originalStep = {
-      id: "step-1",
-      cvid: "cvid-1",
-      name: "Step",
+  test("should process trigger field", () => {
+    var _a, _b, _c;
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
       sequence: 0,
+      data: [],
       trigger: [
         {
           id: "trigger-1",
           actions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
-          conditions: []
+          conditions: [{ id: "condition-1", type: "test", operators: "and", data: {} }]
         }
       ],
-      data: [],
       target: void 0
     };
-    const result = duplicateStepWithRename(originalStep, 1);
+    const result = duplicateStep(step);
     expect((_a = result.trigger) == null ? void 0 : _a[0].id).toBe("mock-cuid");
-  });
-  test("should process target in step duplicate", () => {
-    var _a, _b;
-    const originalStep = {
-      id: "step-1",
-      cvid: "cvid-1",
-      name: "Step",
+    expect((_b = result.trigger) == null ? void 0 : _b[0].actions[0].id).toBe("regenerated-action-1");
+    expect((_c = result.trigger) == null ? void 0 : _c[0].conditions[0].id).toBe("regenerated-condition-1");
+  });
+  test("should process target field with actions", () => {
+    var _a, _b, _c;
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
       sequence: 0,
-      trigger: [],
       data: [],
+      trigger: [],
       target: {
+        selector: ".test",
         actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
       }
     };
-    const result = duplicateStepWithRename(originalStep, 1);
+    const result = duplicateStep(step);
     expect((_b = (_a = result.target) == null ? void 0 : _a.actions) == null ? void 0 : _b[0].id).toBe("regenerated-action-1");
+    expect((_c = result.target) == null ? void 0 : _c.selector).toBe(".test");
   });
-  test("should handle step without trigger", () => {
-    const originalStep = {
-      id: "step-1",
-      cvid: "cvid-1",
-      name: "Step",
+  test("should return empty array for undefined data", () => {
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
+      sequence: 0,
+      data: void 0,
+      trigger: [],
+      target: void 0
+    };
+    const result = duplicateStep(step);
+    expect(result.data).toEqual([]);
+  });
+  test("should return empty array for undefined trigger", () => {
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
       sequence: 0,
-      trigger: void 0,
       data: [],
+      trigger: void 0,
       target: void 0
     };
-    const result = duplicateStepWithRename(originalStep, 1);
+    const result = duplicateStep(step);
     expect(result.trigger).toEqual([]);
   });
-  test("should handle step without data", () => {
-    const originalStep = {
-      id: "step-1",
-      cvid: "cvid-1",
-      name: "Step",
+  test("should return undefined for undefined target", () => {
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
       sequence: 0,
+      data: [],
       trigger: [],
-      data: void 0,
       target: void 0
     };
-    const result = duplicateStepWithRename(originalStep, 1);
-    expect(result.data).toEqual([]);
+    const result = duplicateStep(step);
+    expect(result.target).toBeUndefined();
+  });
+  test("should preserve custom properties", () => {
+    const step = {
+      id: "step-id",
+      cvid: "step-cvid",
+      name: "Test Step",
+      sequence: 0,
+      data: [],
+      trigger: [],
+      target: void 0,
+      customField: "custom-value",
+      anotherField: 123
+    };
+    const result = duplicateStep(step);
+    expect(result.customField).toBe("custom-value");
+    expect(result.anotherField).toBe(123);
   });
 });