@elementor/editor-interactions 4.0.0-619 → 4.0.0-621

package/dist/index.js

@@ -327,13 +327,13 @@ var createInteractionItem = ({
   $$type: "interaction-item",
   value: {
     ...interactionId && { interaction_id: createString(interactionId) },
-    trigger: createString(trigger),
+    trigger: createString(trigger ?? ""),
     animation: createAnimationPreset({
-      effect,
-      type,
+      effect: effect ?? "",
+      type: type ?? "",
       direction,
-      duration,
-      delay,
+      duration: duration ?? 0,
+      delay: delay ?? 0,
       replay,
       easing,
       relativeTo,
@@ -1393,53 +1393,73 @@ var import_editor_mcp = require("@elementor/editor-mcp");
 var MAX_INTERACTIONS_PER_ELEMENT = 5;
 
 // src/mcp/resources/interactions-schema-resource.ts
-var INTERACTIONS_SCHEMA_URI = "elementor://interactions/schema";
-var schema = {
-  triggers: BASE_TRIGGERS.map((key) => ({
-    value: key,
-    label: TRIGGER_OPTIONS[key] ?? key
-  })),
-  effects: [
-    { value: "fade", label: "Fade" },
-    { value: "slide", label: "Slide" },
-    { value: "scale", label: "Scale" }
-  ],
-  effectTypes: [
-    { value: "in", label: "In" },
-    { value: "out", label: "Out" }
-  ],
-  directions: [
-    { value: "top", label: "Top", note: "" },
-    { value: "bottom", label: "Bottom", note: "" },
-    { value: "left", label: "Left", note: "" },
-    { value: "right", label: "Right", note: "" },
-    { value: "", label: "None", note: "Slide animation must have a direction" }
-  ],
-  easings: Object.entries(EASING_OPTIONS).map(([value, label]) => ({ value, label })),
-  timing: {
-    duration: { min: 0, max: 1e4, unit: "ms", description: "Animation duration in milliseconds" },
-    delay: { min: 0, max: 1e4, unit: "ms", description: "Animation delay in milliseconds" }
-  },
-  excludedBreakpoints: {
-    type: "string[]",
-    description: "List of breakpoint IDs on which this interaction is disabled. Omit to enable on all breakpoints."
-  },
-  maxInteractionsPerElement: MAX_INTERACTIONS_PER_ELEMENT
+var import_utils = require("@elementor/utils");
+
+// src/mcp/tools/schema.ts
+var import_schema = require("@elementor/schema");
+var baseSchema = {
+  trigger: import_schema.z.enum(["load", "scrollIn"]).optional().describe("Event that triggers the animation"),
+  effect: import_schema.z.enum(["fade", "slide", "scale"]).optional().describe("Animation effect type"),
+  effectType: import_schema.z.enum(["in", "out"]).optional().describe("Whether the animation plays in or out"),
+  direction: import_schema.z.enum(["top", "bottom", "left", "right", ""]).optional().describe("Direction for slide effect. Use empty string for fade/scale."),
+  duration: import_schema.z.number().min(0).max(1e4).optional().describe("Animation duration in milliseconds"),
+  delay: import_schema.z.number().min(0).max(1e4).optional().describe("Animation delay in milliseconds"),
+  easing: import_schema.z.string().optional().describe("Easing function. See interactions schema for options."),
+  excludedBreakpoints: import_schema.z.array(import_schema.z.string()).optional().describe(
+    'Breakpoint IDs on which this interaction is disabled (e.g. ["mobile", "tablet"]). Omit to enable on all breakpoints.'
+  )
+};
+var proSchema = {
+  trigger: import_schema.z.enum(["load", "scrollIn", "scrollOut", "scrollOn", "hover", "click"]).optional().describe("Event that triggers the animation"),
+  effect: import_schema.z.enum(["fade", "slide", "scale", "custom"]).optional().describe("Animation effect type"),
+  customEffect: import_schema.z.object({
+    keyframes: import_schema.z.array(
+      import_schema.z.object({
+        stop: import_schema.z.number().describe("The stop of the keyframe in percent, can be either 0 or 100"),
+        value: import_schema.z.object({
+          opacity: import_schema.z.number().min(0).max(1).describe("The opacity of the keyframe"),
+          scale: import_schema.z.object({
+            x: import_schema.z.number().min(0).max(1).describe("The x scale of the keyframe"),
+            y: import_schema.z.number().min(0).max(1).describe("The y scale of the keyframe")
+          }).optional().describe("The scale of the keyframe"),
+          rotate: import_schema.z.object({
+            x: import_schema.z.number().min(0).max(360).describe("The x rotate of the keyframe"),
+            y: import_schema.z.number().min(0).max(360).describe("The y rotate of the keyframe"),
+            z: import_schema.z.number().min(0).max(360).describe("The z rotate of the keyframe")
+          }).optional().describe("The rotate of the keyframe"),
+          move: import_schema.z.object({
+            x: import_schema.z.number().min(0).max(1).describe("The x move of the keyframe"),
+            y: import_schema.z.number().min(0).max(1).describe("The y move of the keyframe"),
+            z: import_schema.z.number().min(0).max(1).describe("The z move of the keyframe")
+          }).optional().describe("The move of the keyframe"),
+          skew: import_schema.z.object({
+            x: import_schema.z.number().min(0).max(360).describe("The x skew of the keyframe"),
+            y: import_schema.z.number().min(0).max(360).describe("The y skew of the keyframe")
+          }).optional().describe("The skew of the keyframe")
+        })
+      })
+    ).describe("The keyframes of the custom effect")
+  }).optional().describe("The custom effect to use for the animation")
 };
+
+// src/mcp/resources/interactions-schema-resource.ts
+var INTERACTIONS_SCHEMA_URI = "elementor://interactions/schema";
 var initInteractionsSchemaResource = (reg) => {
   const { resource } = reg;
+  const schema = (0, import_utils.isProActive)() ? { ...baseSchema, ...proSchema } : baseSchema;
   resource(
     "interactions-schema",
     INTERACTIONS_SCHEMA_URI,
     {
-      description: "Schema describing all available options for element interactions (triggers, effects, easings, timing, breakpoints, etc.)."
+      description: "Schema describing all available options for element interactions."
     },
     async () => {
       return {
         contents: [
           {
             uri: INTERACTIONS_SCHEMA_URI,
-            text: JSON.stringify(schema, null, 2)
+            mimeType: "application/json",
+            text: JSON.stringify(schema)
           }
         ]
       };
@@ -1449,85 +1469,49 @@ var initInteractionsSchemaResource = (reg) => {
 
 // src/mcp/tools/manage-element-interaction-tool.ts
 var import_editor_elements5 = require("@elementor/editor-elements");
-var import_schema = require("@elementor/schema");
+var import_schema3 = require("@elementor/schema");
+var import_utils2 = require("@elementor/utils");
 var EMPTY_INTERACTIONS = {
   version: 1,
   items: []
 };
 var initManageElementInteractionTool = (reg) => {
   const { addTool } = reg;
+  const extendedSchema = (0, import_utils2.isProActive)() ? { ...baseSchema, ...proSchema } : baseSchema;
+  const schema = {
+    elementId: import_schema3.z.string().describe("The ID of the element to read or modify interactions on"),
+    action: import_schema3.z.enum(["get", "add", "update", "delete", "clear"]).describe('Operation to perform. Use "get" first to inspect existing interactions.'),
+    interactionId: import_schema3.z.string().optional().describe('Interaction ID \u2014 required for update and delete. Obtain from a prior "get" call.'),
+    ...extendedSchema
+  };
   addTool({
     name: "manage-element-interaction",
-    description: `Read or manage interactions (animations) on an element. Always call with action=get first to see existing interactions before making changes.
-
-Actions:
-- get: Read the current interactions on the element.
-- add: Add a new interaction (max ${MAX_INTERACTIONS_PER_ELEMENT} per element).
-- update: Update an existing interaction by its interactionId.
-- delete: Remove a specific interaction by its interactionId.
-- clear: Remove all interactions from the element.
-
-For add/update, provide: trigger, effect, effectType, direction (empty string for non-slide effects), duration, delay, easing.
-Use excludedBreakpoints to disable the animation on specific responsive breakpoints (e.g. ["mobile", "tablet"]).`,
-    schema: {
-      elementId: import_schema.z.string().describe("The ID of the element to read or modify interactions on"),
-      action: import_schema.z.enum(["get", "add", "update", "delete", "clear"]).describe('Operation to perform. Use "get" first to inspect existing interactions.'),
-      interactionId: import_schema.z.string().optional().describe('Interaction ID \u2014 required for update and delete. Obtain from a prior "get" call.'),
-      trigger: import_schema.z.enum(["load", "scrollIn"]).optional().describe("Event that triggers the animation"),
-      effect: import_schema.z.enum(["fade", "slide", "scale"]).optional().describe("Animation effect type"),
-      effectType: import_schema.z.enum(["in", "out"]).optional().describe("Whether the animation plays in or out"),
-      direction: import_schema.z.enum(["top", "bottom", "left", "right", ""]).optional().describe("Direction for slide effect. Use empty string for fade/scale."),
-      duration: import_schema.z.number().min(0).max(1e4).optional().describe("Animation duration in milliseconds"),
-      delay: import_schema.z.number().min(0).max(1e4).optional().describe("Animation delay in milliseconds"),
-      easing: import_schema.z.string().optional().describe("Easing function. See interactions schema for options."),
-      excludedBreakpoints: import_schema.z.array(import_schema.z.string()).optional().describe(
-        'Breakpoint IDs on which this interaction is disabled (e.g. ["mobile", "tablet"]). Omit to enable on all breakpoints.'
-      )
-    },
+    description: `Manage the element interaction.`,
+    schema,
     requiredResources: [
       { uri: INTERACTIONS_SCHEMA_URI, description: "Interactions schema with all available options" }
     ],
     isDestructive: true,
+    outputSchema: {
+      success: import_schema3.z.boolean().describe("Whether the action was successful"),
+      action: import_schema3.z.enum(["get", "add", "update", "delete", "clear"]).describe('Operation to perform. Use "get" first to inspect existing interactions.'),
+      elementId: import_schema3.z.string().optional().describe("The ID of the element to read or modify interactions on"),
+      interactions: import_schema3.z.array(import_schema3.z.any()).optional().describe("The interactions on the element"),
+      count: import_schema3.z.number().optional().describe("The number of interactions on the element")
+    },
     handler: (input) => {
-      const {
-        elementId,
-        action,
-        interactionId,
-        trigger,
-        effect,
-        effectType,
-        direction,
-        duration,
-        delay,
-        easing,
-        excludedBreakpoints
-      } = input;
+      const { elementId, action, interactionId, ...animationData } = input;
       const allInteractions = interactionsRepository.all();
       const elementData = allInteractions.find((data) => data.elementId === elementId);
       const currentInteractions = elementData?.interactions ?? EMPTY_INTERACTIONS;
       if (action === "get") {
-        const summary = currentInteractions.items.map((item) => {
-          const { value } = item;
-          const animValue = value.animation.value;
-          const timingValue = animValue.timing_config.value;
-          const configValue = animValue.config.value;
-          return {
-            id: extractString(value.interaction_id),
-            trigger: extractString(value.trigger),
-            effect: extractString(animValue.effect),
-            effectType: extractString(animValue.type),
-            direction: extractString(animValue.direction),
-            duration: extractSize(timingValue.duration),
-            delay: extractSize(timingValue.delay),
-            easing: extractString(configValue.easing),
-            excludedBreakpoints: extractExcludedBreakpoints(value.breakpoints)
-          };
-        });
-        return JSON.stringify({
+        return {
+          success: true,
           elementId,
-          interactions: summary,
-          count: summary.length
-        });
+          action,
+          interactions: currentInteractions.items,
+          count: currentInteractions.items.length
+        };
       }
       let updatedItems = [...currentInteractions.items];
       switch (action) {
@@ -1539,15 +1523,7 @@ Use excludedBreakpoints to disable the animation on specific responsive breakpoi
           }
           const newItem = createInteractionItem({
             interactionId: generateTempInteractionId(),
-            trigger: trigger ?? DEFAULT_VALUES.trigger,
-            effect: effect ?? DEFAULT_VALUES.effect,
-            type: effectType ?? DEFAULT_VALUES.type,
-            direction: direction ?? DEFAULT_VALUES.direction,
-            duration: duration ?? DEFAULT_VALUES.duration,
-            delay: delay ?? DEFAULT_VALUES.delay,
-            replay: DEFAULT_VALUES.replay,
-            easing: easing ?? DEFAULT_VALUES.easing,
-            excludedBreakpoints
+            ...animationData
           });
           updatedItems = [...updatedItems, newItem];
           break;
@@ -1564,23 +1540,9 @@ Use excludedBreakpoints to disable the animation on specific responsive breakpoi
               `Interaction with ID "${interactionId}" not found on element "${elementId}".`
             );
           }
-          const existingItem = updatedItems[itemIndex];
-          const existingValue = existingItem.value;
-          const existingAnimation = existingValue.animation.value;
-          const existingTiming = existingAnimation.timing_config.value;
-          const existingConfig = existingAnimation.config.value;
-          const existingExcludedBreakpoints = extractExcludedBreakpoints(existingValue.breakpoints);
           const updatedItem = createInteractionItem({
             interactionId,
-            trigger: trigger ?? extractString(existingValue.trigger),
-            effect: effect ?? extractString(existingAnimation.effect),
-            type: effectType ?? extractString(existingAnimation.type),
-            direction: direction !== void 0 ? direction : extractString(existingAnimation.direction),
-            duration: duration !== void 0 ? duration : extractSize(existingTiming.duration),
-            delay: delay !== void 0 ? delay : extractSize(existingTiming.delay),
-            replay: existingConfig.replay?.value ?? DEFAULT_VALUES.replay,
-            easing: easing ?? extractString(existingConfig.easing),
-            excludedBreakpoints: excludedBreakpoints !== void 0 ? excludedBreakpoints : existingExcludedBreakpoints
+            ...animationData
           });
           updatedItems = [
             ...updatedItems.slice(0, itemIndex),
@@ -1620,12 +1582,12 @@ Use excludedBreakpoints to disable the animation on specific responsive breakpoi
           `Failed to update interactions for element "${elementId}": ${error instanceof Error ? error.message : "Unknown error"}`
         );
       }
-      return JSON.stringify({
+      return {
         success: true,
         action,
         elementId,
-        interactionCount: updatedItems.length
-      });
+        count: updatedItems.length
+      };
     }
   });
 };
@@ -1633,10 +1595,71 @@ Use excludedBreakpoints to disable the animation on specific responsive breakpoi
 // src/mcp/index.ts
 var initMcpInteractions = () => {
   const reg = (0, import_editor_mcp.getMCPByDomain)("interactions", {
-    instructions: "MCP server for managing element interactions and animations. Use this to add, modify, or remove animations and motion effects triggered by user events such as page load or scroll-into-view."
+    instructions: `
+		MCP server for managing element interactions and animations. Use this to add, modify, or remove animations and motion effects triggered by user events such as page load or scroll-into-view.
+		** IMPORTANT **
+		Use the "interactions-schema" resource to get the schema of the interactions.
+		Actions:
+		- get: Read the current interactions on the element.
+		- add: Add a new interaction (max ${MAX_INTERACTIONS_PER_ELEMENT} per element).
+		- update: Update an existing interaction by its interactionId.
+		- delete: Remove a specific interaction by its interactionId.
+		- clear: Remove all interactions from the element.
+		
+		For add/update, provide: trigger, effect, effectType, direction (required for slide effect), duration, delay, easing.
+		Use excludedBreakpoints to disable the animation on specific responsive breakpoints (e.g. ["mobile", "tablet"]).
+		Example Get Request:
+		{
+			"elementId": "123",
+			"action": "get",
+			"interactionId": "123",
+			"animationData": {
+				"trigger": "click",
+				"effect": "fade",
+			}
+		}
+		Example Add Request:
+		{
+			"elementId": "123",
+			"action": "add",
+			"animationData": {
+				"effectType": "in",
+				"direction": "top",
+				"trigger": "click",
+				"effect": "fade",
+				"duration": 1000,
+				"delay": 0,
+				"easing": "easeIn",
+				"excludedBreakpoints": ["mobile", "tablet"],
+			}
+		}
+		Example Update Request:
+		{
+			"elementId": "123",
+			"action": "update",
+			"interactionId": "123",
+			"animationData": {
+				"trigger": "click",
+				"effect": "fade",
+			}
+		}
+		Example Delete Request:
+		{
+			"elementId": "123",
+			"action": "delete",
+			"interactionId": "123",
+		}
+		Example Clear Request:
+		{
+			"elementId": "123",
+			"action": "clear",
+		}
+		`
+  });
+  reg.waitForReady().then(() => {
+    initInteractionsSchemaResource(reg);
+    initManageElementInteractionTool(reg);
   });
-  initInteractionsSchemaResource(reg);
-  initManageElementInteractionTool(reg);
 };
 
 // src/init.ts