@usertour/helpers 0.0.47 → 0.0.48

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

@@ -0,0 +1,716 @@
+import {
+  createStepCopy,
+  duplicateChecklistData,
+  duplicateConfig,
+  duplicateData,
+  duplicateTarget,
+  duplicateTriggers,
+  extractQuestionData,
+  generateUniqueCopyName,
+  hasMissingRequiredData,
+  isClickableElement,
+  isMissingRequiredData,
+  isQuestionElement,
+  isRestrictedType,
+  processQuestionElements
+} from "../chunk-7GJAPR7Y.js";
+import "../chunk-7ODE2AIC.js";
+import "../chunk-SIG4WTEF.js";
+import "../chunk-YYIGUZNZ.js";
+import "../chunk-PAESAL23.js";
+import "../chunk-3KG2HTZ3.js";
+import "../chunk-KYDXF7SU.js";
+import "../chunk-JQWKLXW6.js";
+import "../chunk-GFH3VWOC.js";
+import "../chunk-XEO3YXBM.js";
+
+// src/__tests__/content-helper.test.ts
+import { ContentDataType, ContentEditorElementType } from "@usertour/types";
+jest.mock("../helper", () => ({
+  cuid: jest.fn(() => "mock-cuid"),
+  uuidV4: jest.fn(() => "mock-uuid")
+}));
+jest.mock("../conditions", () => ({
+  regenerateConditionIds: jest.fn(
+    (conditions) => conditions == null ? void 0 : conditions.map((c) => ({ ...c, id: `regenerated-${c.id}` }))
+  )
+}));
+describe("isRestrictedType", () => {
+  test("should return true for NPS type", () => {
+    expect(isRestrictedType(ContentEditorElementType.NPS)).toBe(true);
+  });
+  test("should return true for STAR_RATING type", () => {
+    expect(isRestrictedType(ContentEditorElementType.STAR_RATING)).toBe(true);
+  });
+  test("should return true for SCALE type", () => {
+    expect(isRestrictedType(ContentEditorElementType.SCALE)).toBe(true);
+  });
+  test("should return true for SINGLE_LINE_TEXT type", () => {
+    expect(isRestrictedType(ContentEditorElementType.SINGLE_LINE_TEXT)).toBe(true);
+  });
+  test("should return true for MULTI_LINE_TEXT type", () => {
+    expect(isRestrictedType(ContentEditorElementType.MULTI_LINE_TEXT)).toBe(true);
+  });
+  test("should return true for MULTIPLE_CHOICE type", () => {
+    expect(isRestrictedType(ContentEditorElementType.MULTIPLE_CHOICE)).toBe(true);
+  });
+  test("should return false for BUTTON type", () => {
+    expect(isRestrictedType(ContentEditorElementType.BUTTON)).toBe(false);
+  });
+  test("should return false for TEXT type", () => {
+    expect(isRestrictedType(ContentEditorElementType.TEXT)).toBe(false);
+  });
+  test("should return false for IMAGE type", () => {
+    expect(isRestrictedType(ContentEditorElementType.IMAGE)).toBe(false);
+  });
+});
+describe("isMissingRequiredData", () => {
+  test("should return true when restricted type element has empty name", () => {
+    const element = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "" }
+    };
+    expect(isMissingRequiredData(element)).toBe(true);
+  });
+  test("should return false when restricted type element has undefined name (isEmptyString returns false for undefined)", () => {
+    const element = {
+      type: ContentEditorElementType.NPS,
+      data: {}
+    };
+    expect(isMissingRequiredData(element)).toBe(false);
+  });
+  test("should return false when restricted type element has valid name", () => {
+    const element = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "Valid Name" }
+    };
+    expect(isMissingRequiredData(element)).toBe(false);
+  });
+  test("should return true when button element has empty text", () => {
+    const element = {
+      type: ContentEditorElementType.BUTTON,
+      data: { text: "", actions: [{ id: "1" }] }
+    };
+    expect(isMissingRequiredData(element)).toBe(true);
+  });
+  test("should return true when button element has no actions", () => {
+    const element = {
+      type: ContentEditorElementType.BUTTON,
+      data: { text: "Button", actions: [] }
+    };
+    expect(isMissingRequiredData(element)).toBe(true);
+  });
+  test("should return true when button element has undefined actions", () => {
+    const element = {
+      type: ContentEditorElementType.BUTTON,
+      data: { text: "Button" }
+    };
+    expect(isMissingRequiredData(element)).toBe(true);
+  });
+  test("should return false when button element has valid text and actions", () => {
+    const element = {
+      type: ContentEditorElementType.BUTTON,
+      data: { text: "Button", actions: [{ id: "1" }] }
+    };
+    expect(isMissingRequiredData(element)).toBe(false);
+  });
+  test("should return false for non-restricted, non-button type", () => {
+    const element = {
+      type: ContentEditorElementType.TEXT,
+      data: {}
+    };
+    expect(isMissingRequiredData(element)).toBe(false);
+  });
+});
+describe("hasMissingRequiredData", () => {
+  const createContentRoot = (element) => [
+    {
+      type: "root",
+      children: [
+        {
+          type: "column",
+          children: [
+            {
+              type: "element",
+              element
+            }
+          ]
+        }
+      ]
+    }
+  ];
+  test("should return true when content has element with missing required data", () => {
+    const element = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "" }
+    };
+    const contents = createContentRoot(element);
+    expect(hasMissingRequiredData(contents)).toBe(true);
+  });
+  test("should return false when all elements have required data", () => {
+    const element = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "Valid Name" }
+    };
+    const contents = createContentRoot(element);
+    expect(hasMissingRequiredData(contents)).toBe(false);
+  });
+  test("should return false for empty contents array", () => {
+    expect(hasMissingRequiredData([])).toBe(false);
+  });
+});
+describe("isQuestionElement", () => {
+  test("should return true for SINGLE_LINE_TEXT", () => {
+    const element = { type: ContentEditorElementType.SINGLE_LINE_TEXT };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for MULTI_LINE_TEXT", () => {
+    const element = { type: ContentEditorElementType.MULTI_LINE_TEXT };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for NPS", () => {
+    const element = { type: ContentEditorElementType.NPS };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for STAR_RATING", () => {
+    const element = { type: ContentEditorElementType.STAR_RATING };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for SCALE", () => {
+    const element = { type: ContentEditorElementType.SCALE };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for MULTIPLE_CHOICE", () => {
+    const element = { type: ContentEditorElementType.MULTIPLE_CHOICE };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return false for BUTTON", () => {
+    const element = { type: ContentEditorElementType.BUTTON };
+    expect(isQuestionElement(element)).toBe(false);
+  });
+  test("should return false for TEXT", () => {
+    const element = { type: ContentEditorElementType.TEXT };
+    expect(isQuestionElement(element)).toBe(false);
+  });
+});
+describe("isClickableElement", () => {
+  test("should return true for BUTTON type", () => {
+    const element = { type: ContentEditorElementType.BUTTON, data: {} };
+    expect(isClickableElement(element)).toBe(true);
+  });
+  test("should return true for question elements", () => {
+    const element = { type: ContentEditorElementType.NPS, data: {} };
+    expect(isClickableElement(element)).toBe(true);
+  });
+  test("should return false for non-clickable elements", () => {
+    const element = { type: ContentEditorElementType.TEXT, data: [] };
+    expect(isClickableElement(element)).toBe(false);
+  });
+});
+describe("extractQuestionData", () => {
+  test("should extract question elements from content", () => {
+    const questionElement = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "NPS Question", cvid: "test-cvid" }
+    };
+    const contents = [
+      {
+        type: "root",
+        children: [
+          {
+            type: "column",
+            children: [
+              {
+                type: "element",
+                element: questionElement
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = extractQuestionData(contents);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual(questionElement);
+  });
+  test("should return empty array when no question elements exist", () => {
+    const textElement = {
+      type: ContentEditorElementType.TEXT,
+      data: {}
+    };
+    const contents = [
+      {
+        type: "root",
+        children: [
+          {
+            type: "column",
+            children: [
+              {
+                type: "element",
+                element: textElement
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = extractQuestionData(contents);
+    expect(result).toHaveLength(0);
+  });
+  test("should return empty array for empty contents", () => {
+    const result = extractQuestionData([]);
+    expect(result).toHaveLength(0);
+  });
+  test("should extract multiple question elements", () => {
+    const npsElement = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "NPS" }
+    };
+    const scaleElement = {
+      type: ContentEditorElementType.SCALE,
+      data: { name: "Scale" }
+    };
+    const contents = [
+      {
+        type: "root",
+        children: [
+          {
+            type: "column",
+            children: [
+              { type: "element", element: npsElement },
+              { type: "element", element: scaleElement }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = extractQuestionData(contents);
+    expect(result).toHaveLength(2);
+  });
+});
+describe("processQuestionElements", () => {
+  test("should return empty array for undefined contents", () => {
+    const result = processQuestionElements(void 0);
+    expect(result).toEqual([]);
+  });
+  test("should return empty array for empty contents", () => {
+    const result = processQuestionElements([]);
+    expect(result).toEqual([]);
+  });
+  test("should regenerate cvid for question elements", () => {
+    const questionElement = {
+      type: ContentEditorElementType.NPS,
+      data: { name: "NPS Question", cvid: "old-cvid" }
+    };
+    const contents = [
+      {
+        type: "root",
+        children: [
+          {
+            type: "column",
+            children: [
+              {
+                type: "element",
+                element: questionElement
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = processQuestionElements(contents);
+    const processedElement = result[0].children[0].children[0].element;
+    expect(processedElement.data.cvid).toBe("mock-cuid");
+  });
+  test("should regenerate actions for button elements", () => {
+    var _a;
+    const buttonElement = {
+      type: ContentEditorElementType.BUTTON,
+      data: {
+        text: "Button",
+        actions: [{ id: "action-1", type: "test" }]
+      }
+    };
+    const contents = [
+      {
+        type: "root",
+        children: [
+          {
+            type: "column",
+            children: [
+              {
+                type: "element",
+                element: buttonElement
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = processQuestionElements(contents);
+    const processedElement = result[0].children[0].children[0].element;
+    expect((_a = processedElement.data) == null ? void 0 : _a.actions[0].id).toBe("regenerated-action-1");
+  });
+  test("should not modify non-question, non-button elements", () => {
+    const textElement = {
+      type: ContentEditorElementType.TEXT,
+      data: []
+    };
+    const contents = [
+      {
+        type: "root",
+        children: [
+          {
+            type: "column",
+            children: [
+              {
+                type: "element",
+                element: textElement
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const result = processQuestionElements(contents);
+    const processedElement = result[0].children[0].children[0].element;
+    expect(processedElement).toEqual(textElement);
+  });
+});
+describe("generateUniqueCopyName", () => {
+  test('should generate "Name (copy)" for first copy', () => {
+    const result = generateUniqueCopyName("Test");
+    expect(result).toBe("Test (copy)");
+  });
+  test('should generate "Name (copy)" when no existing names provided', () => {
+    const result = generateUniqueCopyName("Test", []);
+    expect(result).toBe("Test (copy)");
+  });
+  test('should generate "Name (copy 2)" when "Name (copy)" exists', () => {
+    const result = generateUniqueCopyName("Test", ["Test (copy)"]);
+    expect(result).toBe("Test (copy 2)");
+  });
+  test('should generate "Name (copy 3)" when "Name (copy)" and "Name (copy 2)" exist', () => {
+    const result = generateUniqueCopyName("Test", ["Test (copy)", "Test (copy 2)"]);
+    expect(result).toBe("Test (copy 3)");
+  });
+  test("should find next available number", () => {
+    const result = generateUniqueCopyName("Test", [
+      "Test (copy)",
+      "Test (copy 2)",
+      "Test (copy 3)",
+      "Test (copy 4)"
+    ]);
+    expect(result).toBe("Test (copy 5)");
+  });
+});
+describe("duplicateTriggers", () => {
+  test("should return triggers as-is when not an array", () => {
+    const result = duplicateTriggers(null);
+    expect(result).toBeNull();
+  });
+  test("should regenerate trigger IDs", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
+        conditions: [{ id: "condition-1", type: "test", operators: "and", data: {} }]
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].id).toBe("mock-cuid");
+  });
+  test("should regenerate action IDs", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
+        conditions: []
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].actions[0].id).toBe("regenerated-action-1");
+  });
+  test("should regenerate condition IDs", () => {
+    const triggers = [
+      {
+        id: "trigger-1",
+        actions: [],
+        conditions: [{ id: "condition-1", type: "test", operators: "and", data: {} }]
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].conditions[0].id).toBe("regenerated-condition-1");
+  });
+  test("should handle triggers without actions or conditions", () => {
+    const triggers = [
+      {
+        id: "trigger-1"
+      }
+    ];
+    const result = duplicateTriggers(triggers);
+    expect(result[0].id).toBe("mock-cuid");
+    expect(result[0].actions).toBeUndefined();
+    expect(result[0].conditions).toBeUndefined();
+  });
+});
+describe("duplicateTarget", () => {
+  test("should return undefined for undefined target", () => {
+    const result = duplicateTarget(void 0);
+    expect(result).toBeUndefined();
+  });
+  test("should return undefined for null target", () => {
+    const result = duplicateTarget(null);
+    expect(result).toBeUndefined();
+  });
+  test("should regenerate action IDs in target", () => {
+    var _a;
+    const target = {
+      actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+    };
+    const result = duplicateTarget(target);
+    expect((_a = result == null ? void 0 : result.actions) == null ? void 0 : _a[0].id).toBe("regenerated-action-1");
+  });
+  test("should return target as-is when no actions", () => {
+    const target = {
+      selector: ".test"
+    };
+    const result = duplicateTarget(target);
+    expect(result).toEqual(target);
+  });
+  test("should return target as-is when actions is not an array", () => {
+    const target = {
+      actions: "not-an-array"
+    };
+    const result = duplicateTarget(target);
+    expect(result).toEqual(target);
+  });
+});
+describe("duplicateChecklistData", () => {
+  test("should return data as-is for null", () => {
+    const result = duplicateChecklistData(null);
+    expect(result).toBeNull();
+  });
+  test("should return data as-is for undefined", () => {
+    const result = duplicateChecklistData(void 0);
+    expect(result).toBeUndefined();
+  });
+  test("should return data as-is for non-object", () => {
+    const result = duplicateChecklistData("string");
+    expect(result).toBe("string");
+  });
+  test("should return data as-is when items is not an array", () => {
+    const data = { items: "not-an-array" };
+    const result = duplicateChecklistData(data);
+    expect(result).toEqual(data);
+  });
+  test("should regenerate item IDs", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          title: "Task 1",
+          clickedActions: [],
+          completeConditions: [],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items[0].id).toBe("mock-uuid");
+  });
+  test("should regenerate clickedActions IDs", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          clickedActions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
+          completeConditions: [],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items[0].clickedActions[0].id).toBe("regenerated-action-1");
+  });
+  test("should regenerate completeConditions IDs", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          clickedActions: [],
+          completeConditions: [{ id: "condition-1", type: "test", operators: "and", data: {} }],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items[0].completeConditions[0].id).toBe("regenerated-condition-1");
+  });
+  test("should regenerate onlyShowTaskConditions IDs", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          clickedActions: [],
+          completeConditions: [],
+          onlyShowTaskConditions: [{ id: "condition-1", type: "test", operators: "and", data: {} }]
+        }
+      ]
+    };
+    const result = duplicateChecklistData(data);
+    expect(result.items[0].onlyShowTaskConditions[0].id).toBe("regenerated-condition-1");
+  });
+});
+describe("duplicateConfig", () => {
+  test("should return config as-is for null", () => {
+    const result = duplicateConfig(null);
+    expect(result).toBeNull();
+  });
+  test("should return config as-is for undefined", () => {
+    const result = duplicateConfig(void 0);
+    expect(result).toBeUndefined();
+  });
+  test("should regenerate autoStartRules IDs", () => {
+    var _a;
+    const config = {
+      autoStartRules: [{ id: "rule-1", type: "test", operators: "and", data: {} }]
+    };
+    const result = duplicateConfig(config);
+    expect((_a = result.autoStartRules) == null ? void 0 : _a[0].id).toBe("regenerated-rule-1");
+  });
+  test("should regenerate hideRules IDs", () => {
+    var _a;
+    const config = {
+      hideRules: [{ id: "rule-1", type: "test", operators: "and", data: {} }]
+    };
+    const result = duplicateConfig(config);
+    expect((_a = result.hideRules) == null ? void 0 : _a[0].id).toBe("regenerated-rule-1");
+  });
+  test("should handle config without rules", () => {
+    const config = {
+      someOtherProperty: "value"
+    };
+    const result = duplicateConfig(config);
+    expect(result.autoStartRules).toBeUndefined();
+    expect(result.hideRules).toBeUndefined();
+  });
+});
+describe("duplicateData", () => {
+  test("should process checklist data for CHECKLIST content type", () => {
+    const data = {
+      items: [
+        {
+          id: "item-1",
+          clickedActions: [],
+          completeConditions: [],
+          onlyShowTaskConditions: []
+        }
+      ]
+    };
+    const result = duplicateData(data, ContentDataType.CHECKLIST);
+    expect(result.items[0].id).toBe("mock-uuid");
+  });
+  test("should return data as-is for non-CHECKLIST content type", () => {
+    const data = { someData: "value" };
+    const result = duplicateData(data, "flow");
+    expect(result).toEqual(data);
+  });
+});
+describe("createStepCopy", () => {
+  test("should create a copy of the step with new name", () => {
+    const originalStep = {
+      id: "step-1",
+      cvid: "cvid-1",
+      name: "Original Step",
+      sequence: 0,
+      trigger: [],
+      data: [],
+      target: void 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const result = createStepCopy(originalStep, 1);
+    expect(result.name).toBe("Original Step (copy)");
+    expect(result.sequence).toBe(1);
+    expect(result).not.toHaveProperty("id");
+    expect(result).not.toHaveProperty("cvid");
+    expect(result).not.toHaveProperty("createdAt");
+    expect(result).not.toHaveProperty("updatedAt");
+  });
+  test("should generate unique name when existing names provided", () => {
+    const originalStep = {
+      id: "step-1",
+      cvid: "cvid-1",
+      name: "Step",
+      sequence: 0,
+      trigger: [],
+      data: [],
+      target: void 0
+    };
+    const result = createStepCopy(originalStep, 1, ["Step (copy)"]);
+    expect(result.name).toBe("Step (copy 2)");
+  });
+  test("should process triggers in step copy", () => {
+    var _a;
+    const originalStep = {
+      id: "step-1",
+      cvid: "cvid-1",
+      name: "Step",
+      sequence: 0,
+      trigger: [
+        {
+          id: "trigger-1",
+          actions: [{ id: "action-1", type: "test", operators: "and", data: {} }],
+          conditions: []
+        }
+      ],
+      data: [],
+      target: void 0
+    };
+    const result = createStepCopy(originalStep, 1);
+    expect((_a = result.trigger) == null ? void 0 : _a[0].id).toBe("mock-cuid");
+  });
+  test("should process target in step copy", () => {
+    var _a, _b;
+    const originalStep = {
+      id: "step-1",
+      cvid: "cvid-1",
+      name: "Step",
+      sequence: 0,
+      trigger: [],
+      data: [],
+      target: {
+        actions: [{ id: "action-1", type: "test", operators: "and", data: {} }]
+      }
+    };
+    const result = createStepCopy(originalStep, 1);
+    expect((_b = (_a = result.target) == null ? void 0 : _a.actions) == null ? void 0 : _b[0].id).toBe("regenerated-action-1");
+  });
+  test("should handle step without trigger", () => {
+    const originalStep = {
+      id: "step-1",
+      cvid: "cvid-1",
+      name: "Step",
+      sequence: 0,
+      trigger: void 0,
+      data: [],
+      target: void 0
+    };
+    const result = createStepCopy(originalStep, 1);
+    expect(result.trigger).toEqual([]);
+  });
+  test("should handle step without data", () => {
+    const originalStep = {
+      id: "step-1",
+      cvid: "cvid-1",
+      name: "Step",
+      sequence: 0,
+      trigger: [],
+      data: void 0,
+      target: void 0
+    };
+    const result = createStepCopy(originalStep, 1);
+    expect(result.data).toEqual([]);
+  });
+});