@usertour/helpers 0.0.47 → 0.0.48

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

@@ -0,0 +1,1009 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/__tests__/content-helper.test.ts
+var import_types4 = require("@usertour/types");
+
+// src/content-helper.ts
+var import_types3 = require("@usertour/types");
+
+// src/helper.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+var import_uuid = require("uuid");
+var import_cuid2 = require("@paralleldrive/cuid2");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+var cuid = () => {
+  return (0, import_cuid2.createId)();
+};
+function formatDate(input) {
+  const date = new Date(input);
+  return date.toLocaleDateString("en-US", {
+    month: "long",
+    day: "numeric",
+    year: "numeric"
+  });
+}
+function absoluteUrl(path) {
+  return `${path}`;
+}
+var uuidV4 = () => {
+  return (0, import_uuid.v4)();
+};
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: Number.parseInt(result[1], 16),
+    g: Number.parseInt(result[2], 16),
+    b: Number.parseInt(result[3], 16)
+  } : null;
+}
+var isDark = (hex) => {
+  const rgb = hexToRgb(hex);
+  if (!rgb) {
+    return null;
+  }
+  const { r, g, b } = rgb;
+  if (r * 0.299 + g * 0.587 + b * 0.114 > 186) {
+    return true;
+  }
+  return false;
+};
+var evalCode = (code) => {
+  try {
+    return eval(code);
+  } catch (error) {
+    console.error("Usertour.js: Error evaluating code:", error);
+    return null;
+  }
+};
+var getRandomColor = () => {
+  const colors = [
+    "bg-red-500",
+    "bg-orange-500",
+    "bg-yellow-500",
+    "bg-green-500",
+    "bg-teal-500",
+    "bg-blue-500",
+    "bg-indigo-500",
+    "bg-purple-500",
+    "bg-pink-500",
+    "bg-rose-500"
+  ];
+  return colors[Math.floor(Math.random() * colors.length)];
+};
+
+// src/conditions/condition.ts
+var import_types2 = require("@usertour/types");
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+
+// src/conditions/time.ts
+var import_date_fns = require("date-fns");
+
+// src/type-utils.ts
+var nativeIsArray = Array.isArray;
+var ObjProto = Object.prototype;
+var objToString = ObjProto.toString;
+var objHasOwn = ObjProto.hasOwnProperty;
+var isArray = nativeIsArray || ((obj) => objToString.call(obj) === "[object Array]");
+var isObject = (x) => {
+  return x === Object(x) && !isArray(x);
+};
+var isString = (x) => {
+  return objToString.call(x) === "[object String]";
+};
+var isEmptyString = (x) => isString(x) && x.trim().length === 0;
+
+// src/conditions/attribute.ts
+var import_types = require("@usertour/types");
+var import_date_fns2 = require("date-fns");
+
+// src/conditions/condition.ts
+var regenerateConditionIds = (conditions) => {
+  return conditions.map((condition) => ({
+    ...condition,
+    id: cuid(),
+    conditions: condition.conditions ? regenerateConditionIds(condition.conditions) : void 0
+  }));
+};
+
+// src/content-helper.ts
+var isRestrictedType = (type) => {
+  const restrictedTypes = [
+    import_types3.ContentEditorElementType.NPS,
+    import_types3.ContentEditorElementType.STAR_RATING,
+    import_types3.ContentEditorElementType.SCALE,
+    import_types3.ContentEditorElementType.SINGLE_LINE_TEXT,
+    import_types3.ContentEditorElementType.MULTI_LINE_TEXT,
+    import_types3.ContentEditorElementType.MULTIPLE_CHOICE
+  ];
+  return restrictedTypes.includes(type);
+};
+var isMissingRequiredData = (element) => {
+  var _a, _b, _c, _d;
+  if (isRestrictedType(element.type)) {
+    return isEmptyString((_a = element.data) == null ? void 0 : _a.name);
+  }
+  if (element.type === import_types3.ContentEditorElementType.BUTTON) {
+    if (isEmptyString((_b = element.data) == null ? void 0 : _b.text)) {
+      return true;
+    }
+    if (!((_c = element == null ? void 0 : element.data) == null ? void 0 : _c.actions) || ((_d = element == null ? void 0 : element.data) == null ? void 0 : _d.actions.length) === 0) {
+      return true;
+    }
+  }
+  return false;
+};
+var hasMissingRequiredData = (contents) => {
+  return contents.some(
+    (group) => group.children.some(
+      (column) => column.children.some((item) => isMissingRequiredData(item.element))
+    )
+  );
+};
+var isQuestionElement = (element) => {
+  return element.type === import_types3.ContentEditorElementType.SINGLE_LINE_TEXT || element.type === import_types3.ContentEditorElementType.MULTI_LINE_TEXT || element.type === import_types3.ContentEditorElementType.NPS || element.type === import_types3.ContentEditorElementType.STAR_RATING || element.type === import_types3.ContentEditorElementType.SCALE || element.type === import_types3.ContentEditorElementType.MULTIPLE_CHOICE;
+};
+var isClickableElement = (element) => {
+  return element.type === import_types3.ContentEditorElementType.BUTTON || isQuestionElement(element);
+};
+var extractQuestionData = (data) => {
+  const result = [];
+  function isQuestionRootElement(item) {
+    return "element" in item && isQuestionElement(item.element);
+  }
+  function traverse(item) {
+    if (isQuestionRootElement(item)) {
+      result.push(item.element);
+    }
+    if ("children" in item && item.children) {
+      for (const child of item.children) {
+        traverse(child);
+      }
+    }
+  }
+  for (const item of data) {
+    traverse(item);
+  }
+  return result;
+};
+var processQuestionElements = (contents) => {
+  if (!contents || !isArray(contents) || contents.length === 0) {
+    return [];
+  }
+  return contents.map((group) => ({
+    ...group,
+    children: group.children.map((column) => ({
+      ...column,
+      children: column.children.map((item) => {
+        var _a, _b;
+        const element = item.element;
+        if (isQuestionElement(element)) {
+          const questionElement = element;
+          const updatedElement = {
+            ...questionElement,
+            data: {
+              ...questionElement.data,
+              cvid: cuid(),
+              ...((_a = questionElement.data) == null ? void 0 : _a.actions) && isArray(questionElement.data.actions) ? { actions: regenerateConditionIds(questionElement.data.actions) } : {}
+            }
+          };
+          return {
+            ...item,
+            element: updatedElement
+          };
+        }
+        if (element.type === import_types3.ContentEditorElementType.BUTTON) {
+          const buttonElement = element;
+          if (((_b = buttonElement.data) == null ? void 0 : _b.actions) && isArray(buttonElement.data.actions)) {
+            return {
+              ...item,
+              element: {
+                ...buttonElement,
+                data: {
+                  ...buttonElement.data,
+                  actions: regenerateConditionIds(buttonElement.data.actions)
+                }
+              }
+            };
+          }
+        }
+        return item;
+      })
+    }))
+  }));
+};
+var generateUniqueCopyName = (originalName, existingNames) => {
+  let name = `${originalName} (copy)`;
+  if (existingNames == null ? void 0 : existingNames.includes(name)) {
+    let number = 2;
+    while (existingNames.includes(`${originalName} (copy ${number})`)) {
+      number++;
+    }
+    name = `${originalName} (copy ${number})`;
+  }
+  return name;
+};
+var duplicateTriggers = (triggers) => {
+  if (!isArray(triggers)) {
+    return triggers;
+  }
+  return triggers.map((trigger) => ({
+    ...trigger,
+    id: cuid(),
+    actions: isArray(trigger.actions) ? regenerateConditionIds(trigger.actions) : trigger.actions,
+    conditions: isArray(trigger.conditions) ? regenerateConditionIds(trigger.conditions) : trigger.conditions
+  }));
+};
+var duplicateTarget = (target) => {
+  if (!target) {
+    return void 0;
+  }
+  if (target.actions && isArray(target.actions)) {
+    return {
+      ...target,
+      actions: regenerateConditionIds(target.actions)
+    };
+  }
+  return target;
+};
+var duplicateChecklistData = (data) => {
+  if (!data || !isObject(data) || !isArray(data.items)) {
+    return data;
+  }
+  const checklistData = data;
+  return {
+    ...checklistData,
+    items: checklistData.items.map((item) => ({
+      ...item,
+      id: uuidV4(),
+      clickedActions: isArray(item.clickedActions) ? regenerateConditionIds(item.clickedActions) : item.clickedActions,
+      completeConditions: isArray(item.completeConditions) ? regenerateConditionIds(item.completeConditions) : item.completeConditions,
+      onlyShowTaskConditions: isArray(item.onlyShowTaskConditions) ? regenerateConditionIds(item.onlyShowTaskConditions) : item.onlyShowTaskConditions
+    }))
+  };
+};
+var duplicateConfig = (config) => {
+  if (!config) {
+    return config;
+  }
+  return {
+    ...config,
+    autoStartRules: config.autoStartRules ? regenerateConditionIds(config.autoStartRules) : config.autoStartRules,
+    hideRules: config.hideRules ? regenerateConditionIds(config.hideRules) : config.hideRules
+  };
+};
+var duplicateData = (data, contentType) => {
+  if (contentType === import_types3.ContentDataType.CHECKLIST) {
+    return duplicateChecklistData(data);
+  }
+  return data;
+};
+var createStepCopy = (originalStep, sequence, existingStepNames) => {
+  const { id, cvid, updatedAt, createdAt, ...rest } = originalStep;
+  const name = generateUniqueCopyName(originalStep == null ? void 0 : originalStep.name, existingStepNames);
+  const trigger = (originalStep == null ? void 0 : originalStep.trigger) ? duplicateTriggers(originalStep == null ? void 0 : originalStep.trigger) : [];
+  const data = (originalStep == null ? void 0 : originalStep.data) ? processQuestionElements(originalStep == null ? void 0 : originalStep.data) : [];
+  const target = duplicateTarget(originalStep == null ? void 0 : originalStep.target);
+  return {
+    ...rest,
+    data,
+    trigger,
+    target,
+    name,
+    sequence
+  };
+};
+
+// src/__tests__/content-helper.test.ts
+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(import_types4.ContentEditorElementType.NPS)).toBe(true);
+  });
+  test("should return true for STAR_RATING type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.STAR_RATING)).toBe(true);
+  });
+  test("should return true for SCALE type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.SCALE)).toBe(true);
+  });
+  test("should return true for SINGLE_LINE_TEXT type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.SINGLE_LINE_TEXT)).toBe(true);
+  });
+  test("should return true for MULTI_LINE_TEXT type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.MULTI_LINE_TEXT)).toBe(true);
+  });
+  test("should return true for MULTIPLE_CHOICE type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.MULTIPLE_CHOICE)).toBe(true);
+  });
+  test("should return false for BUTTON type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.BUTTON)).toBe(false);
+  });
+  test("should return false for TEXT type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.TEXT)).toBe(false);
+  });
+  test("should return false for IMAGE type", () => {
+    expect(isRestrictedType(import_types4.ContentEditorElementType.IMAGE)).toBe(false);
+  });
+});
+describe("isMissingRequiredData", () => {
+  test("should return true when restricted type element has empty name", () => {
+    const element = {
+      type: import_types4.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: import_types4.ContentEditorElementType.NPS,
+      data: {}
+    };
+    expect(isMissingRequiredData(element)).toBe(false);
+  });
+  test("should return false when restricted type element has valid name", () => {
+    const element = {
+      type: import_types4.ContentEditorElementType.NPS,
+      data: { name: "Valid Name" }
+    };
+    expect(isMissingRequiredData(element)).toBe(false);
+  });
+  test("should return true when button element has empty text", () => {
+    const element = {
+      type: import_types4.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: import_types4.ContentEditorElementType.BUTTON,
+      data: { text: "Button", actions: [] }
+    };
+    expect(isMissingRequiredData(element)).toBe(true);
+  });
+  test("should return true when button element has undefined actions", () => {
+    const element = {
+      type: import_types4.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: import_types4.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: import_types4.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: import_types4.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: import_types4.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: import_types4.ContentEditorElementType.SINGLE_LINE_TEXT };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for MULTI_LINE_TEXT", () => {
+    const element = { type: import_types4.ContentEditorElementType.MULTI_LINE_TEXT };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for NPS", () => {
+    const element = { type: import_types4.ContentEditorElementType.NPS };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for STAR_RATING", () => {
+    const element = { type: import_types4.ContentEditorElementType.STAR_RATING };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for SCALE", () => {
+    const element = { type: import_types4.ContentEditorElementType.SCALE };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return true for MULTIPLE_CHOICE", () => {
+    const element = { type: import_types4.ContentEditorElementType.MULTIPLE_CHOICE };
+    expect(isQuestionElement(element)).toBe(true);
+  });
+  test("should return false for BUTTON", () => {
+    const element = { type: import_types4.ContentEditorElementType.BUTTON };
+    expect(isQuestionElement(element)).toBe(false);
+  });
+  test("should return false for TEXT", () => {
+    const element = { type: import_types4.ContentEditorElementType.TEXT };
+    expect(isQuestionElement(element)).toBe(false);
+  });
+});
+describe("isClickableElement", () => {
+  test("should return true for BUTTON type", () => {
+    const element = { type: import_types4.ContentEditorElementType.BUTTON, data: {} };
+    expect(isClickableElement(element)).toBe(true);
+  });
+  test("should return true for question elements", () => {
+    const element = { type: import_types4.ContentEditorElementType.NPS, data: {} };
+    expect(isClickableElement(element)).toBe(true);
+  });
+  test("should return false for non-clickable elements", () => {
+    const element = { type: import_types4.ContentEditorElementType.TEXT, data: [] };
+    expect(isClickableElement(element)).toBe(false);
+  });
+});
+describe("extractQuestionData", () => {
+  test("should extract question elements from content", () => {
+    const questionElement = {
+      type: import_types4.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: import_types4.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: import_types4.ContentEditorElementType.NPS,
+      data: { name: "NPS" }
+    };
+    const scaleElement = {
+      type: import_types4.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: import_types4.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: import_types4.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: import_types4.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, import_types4.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([]);
+  });
+});