@elementor/editor-canvas 4.4.0-1144 → 4.4.0-1145

package/dist/index.js

@@ -1799,6 +1799,7 @@ var import_editor_elements4 = require("@elementor/editor-elements");
 var FORM_ELEMENT_TYPE = "e-form";
 var FORM_HIDDEN_FIELD_ELEMENT_TYPE = "e-form-hidden";
 var FORM_HONEYPOT_ELEMENT_TYPE = "e-form-honeypot";
+var FORM_RECAPTCHA_SCORE_ELEMENT_TYPE = "e-form-recaptcha-score";
 var FORM_FIELD_ELEMENT_TYPES = /* @__PURE__ */ new Set([
   "e-form-input",
   "e-form-textarea",
@@ -1811,7 +1812,8 @@ var FORM_FIELD_ELEMENT_TYPES = /* @__PURE__ */ new Set([
   "e-form-date-picker",
   "e-form-time-picker",
   FORM_HIDDEN_FIELD_ELEMENT_TYPE,
-  FORM_HONEYPOT_ELEMENT_TYPE
+  FORM_HONEYPOT_ELEMENT_TYPE,
+  FORM_RECAPTCHA_SCORE_ELEMENT_TYPE
 ]);
 function getArgsElementType(args) {
   return args.model?.widgetType || args.model?.elType;
@@ -1947,112 +1949,128 @@ function handleBlockedFormField() {
   (0, import_editor_notifications.notify)(FORM_FIELDS_OUTSIDE_ALERT);
 }
 
-// src/form-structure/hidden-field-hint.ts
+// src/form-structure/form-atom-added-hints.ts
 var import_editor_notifications2 = require("@elementor/editor-notifications");
 var import_editor_v1_adapters12 = require("@elementor/editor-v1-adapters");
 var import_i18n2 = require("@wordpress/i18n");
 var MOVE_COMMAND = "document/elements/move";
+var FORM_ATOM_HINTS = {
+  [FORM_HONEYPOT_ELEMENT_TYPE]: {
+    idPrefix: "honeypot-added",
+    getMessage: () => (0, import_i18n2.__)("Honeypot added - invisible on your form. Reorder it in the Structure panel.", "elementor")
+  },
+  [FORM_RECAPTCHA_SCORE_ELEMENT_TYPE]: {
+    idPrefix: "recaptcha-score-added",
+    getMessage: () => (0, import_i18n2.__)("Score-based reCAPTCHA added - You can adjust its settings from the Structure panel.", "elementor")
+  }
+};
 var notificationCounter = 0;
-function createHiddenFieldNotification() {
-  return {
-    type: "default",
-    message: (0, import_i18n2.__)("Hidden field added - invisible on your form. Manage it in the Structure panel.", "elementor"),
-    id: `hidden-field-added-${++notificationCounter}`
-  };
-}
-function initHiddenFieldHint() {
+function initFormAtomAddedHints() {
   (0, import_editor_v1_adapters12.registerDataHook)("after", "document/elements/create", (args, _result, options) => {
     if (options?.commandsCurrentTrace?.includes(MOVE_COMMAND)) {
       return;
     }
-    if (getArgsElementType(args) === FORM_HIDDEN_FIELD_ELEMENT_TYPE) {
-      (0, import_editor_notifications2.notify)(createHiddenFieldNotification());
+    const elementType = getArgsElementType(args);
+    const hint = elementType ? FORM_ATOM_HINTS[elementType] : void 0;
+    if (!hint) {
+      return;
     }
+    (0, import_editor_notifications2.notify)({
+      type: "default",
+      message: hint.getMessage(),
+      id: `${hint.idPrefix}-${++notificationCounter}`
+    });
   });
 }
 
-// src/form-structure/honeypot-hint.ts
+// src/form-structure/hidden-field-hint.ts
 var import_editor_notifications3 = require("@elementor/editor-notifications");
 var import_editor_v1_adapters13 = require("@elementor/editor-v1-adapters");
 var import_i18n3 = require("@wordpress/i18n");
 var MOVE_COMMAND2 = "document/elements/move";
 var notificationCounter2 = 0;
-function createHoneypotNotification() {
+function createHiddenFieldNotification() {
   return {
     type: "default",
-    message: (0, import_i18n3.__)("Honeypot added - invisible on your form. Reorder it in the Structure panel.", "elementor"),
-    id: `honeypot-added-${++notificationCounter2}`
+    message: (0, import_i18n3.__)("Hidden field added - invisible on your form. Manage it in the Structure panel.", "elementor"),
+    id: `hidden-field-added-${++notificationCounter2}`
   };
 }
-function initHoneypotHint() {
+function initHiddenFieldHint() {
   (0, import_editor_v1_adapters13.registerDataHook)("after", "document/elements/create", (args, _result, options) => {
     if (options?.commandsCurrentTrace?.includes(MOVE_COMMAND2)) {
       return;
     }
-    if (getArgsElementType(args) === FORM_HONEYPOT_ELEMENT_TYPE) {
-      (0, import_editor_notifications3.notify)(createHoneypotNotification());
+    if (getArgsElementType(args) === FORM_HIDDEN_FIELD_ELEMENT_TYPE) {
+      (0, import_editor_notifications3.notify)(createHiddenFieldNotification());
     }
   });
 }
 
-// src/form-structure/prevent-duplicate-honeypot-commands.ts
+// src/form-structure/prevent-duplicate-form-atoms-commands.ts
 var import_editor_elements5 = require("@elementor/editor-elements");
 var import_editor_notifications4 = require("@elementor/editor-notifications");
 var import_editor_v1_adapters14 = require("@elementor/editor-v1-adapters");
 var import_i18n4 = require("@wordpress/i18n");
 var MOVE_COMMAND3 = "document/elements/move";
-var DUPLICATE_HONEYPOT_ALERT = {
-  type: "default",
-  message: (0, import_i18n4.__)("Only one Honeypot can be added per form.", "elementor"),
-  id: "duplicate-honeypot-blocked"
+var SINGLE_INSTANCE_FORM_ATOM_ALERTS = {
+  [FORM_HONEYPOT_ELEMENT_TYPE]: {
+    type: "default",
+    message: (0, import_i18n4.__)("Only one Honeypot can be added per form.", "elementor"),
+    id: "duplicate-honeypot-blocked"
+  },
+  [FORM_RECAPTCHA_SCORE_ELEMENT_TYPE]: {
+    type: "default",
+    message: (0, import_i18n4.__)("Only one Score-based reCAPTCHA can be added per form.", "elementor"),
+    id: "duplicate-recaptcha-score-blocked"
+  }
 };
-function initDuplicateHoneypotPrevention() {
+var SINGLE_INSTANCE_FORM_ATOM_TYPES = Object.keys(SINGLE_INSTANCE_FORM_ATOM_ALERTS);
+function initDuplicateFormAtomsPrevention() {
   (0, import_editor_v1_adapters14.registerDataHook)("dependency", "document/elements/create", (args, options) => {
-    return !blockHoneypotCreate(args, options);
+    return !blockDuplicateCreate(args, options);
   });
   (0, import_editor_v1_adapters14.blockCommand)({
     command: "document/elements/move",
-    condition: blockHoneypotMove
+    condition: blockDuplicateMove
   });
 }
-function blockHoneypotCreate(args, options) {
+function blockDuplicateCreate(args, options) {
   if (options?.commandsCurrentTrace?.includes(MOVE_COMMAND3)) {
     return false;
   }
-  if (!hasModelElementType(args.model, FORM_HONEYPOT_ELEMENT_TYPE)) {
-    return false;
-  }
   const containers = args.containers ?? [args.container];
-  if (containers.some((container) => formHasHoneypot(getFormContainer(container)))) {
-    handleBlockedHoneypot();
-    return true;
+  const blockedType = SINGLE_INSTANCE_FORM_ATOM_TYPES.find(
+    (type) => hasModelElementType(args.model, type) && containers.some((container) => formHasElementType(getFormContainer(container), type))
+  );
+  if (!blockedType) {
+    return false;
   }
-  return false;
+  (0, import_editor_notifications4.notify)(SINGLE_INSTANCE_FORM_ATOM_ALERTS[blockedType]);
+  return true;
 }
-function blockHoneypotMove(args) {
+function blockDuplicateMove(args) {
   const { containers = [args.container], target } = args;
   const movedContainers = containers.filter((container) => !!container);
-  if (!movedContainers.some((container) => hasElementType(container, FORM_HONEYPOT_ELEMENT_TYPE))) {
-    return false;
-  }
   const movedElements = new Set(movedContainers.flatMap((container) => (0, import_editor_elements5.getAllDescendants)(container)));
-  if (formHasHoneypot(getFormContainer(target), movedElements)) {
-    handleBlockedHoneypot();
-    return true;
+  const targetForm = getFormContainer(target);
+  const blockedType = SINGLE_INSTANCE_FORM_ATOM_TYPES.find(
+    (type) => movedContainers.some((container) => hasElementType(container, type)) && formHasElementType(targetForm, type, movedElements)
+  );
+  if (!blockedType) {
+    return false;
   }
-  return false;
+  (0, import_editor_notifications4.notify)(SINGLE_INSTANCE_FORM_ATOM_ALERTS[blockedType]);
+  return true;
 }
-function formHasHoneypot(form, excluded = /* @__PURE__ */ new Set()) {
+function formHasElementType(form, type, excluded = /* @__PURE__ */ new Set()) {
   if (!form) {
     return false;
   }
   return (0, import_editor_elements5.getAllDescendants)(form).some(
-    (element) => !excluded.has(element) && getElementType(element) === FORM_HONEYPOT_ELEMENT_TYPE
+    (element) => !excluded.has(element) && getElementType(element) === type
   );
 }
-function handleBlockedHoneypot() {
-  (0, import_editor_notifications4.notify)(DUPLICATE_HONEYPOT_ALERT);
-}
 
 // src/form-structure/prevent-form-nesting-commands.ts
 var import_editor_notifications5 = require("@elementor/editor-notifications");
@@ -6087,8 +6105,8 @@ function init() {
   initFormNestingPrevention();
   initFormAncestorEnforcement();
   initHiddenFieldHint();
-  initDuplicateHoneypotPrevention();
-  initHoneypotHint();
+  initDuplicateFormAtomsPrevention();
+  initFormAtomAddedHints();
   initViewReplacements();
   initLegacyViews();
   initSettingsTransformers();

package/dist/index.mjs

@@ -1751,6 +1751,7 @@ import { getAllDescendants } from "@elementor/editor-elements";
 var FORM_ELEMENT_TYPE = "e-form";
 var FORM_HIDDEN_FIELD_ELEMENT_TYPE = "e-form-hidden";
 var FORM_HONEYPOT_ELEMENT_TYPE = "e-form-honeypot";
+var FORM_RECAPTCHA_SCORE_ELEMENT_TYPE = "e-form-recaptcha-score";
 var FORM_FIELD_ELEMENT_TYPES = /* @__PURE__ */ new Set([
   "e-form-input",
   "e-form-textarea",
@@ -1763,7 +1764,8 @@ var FORM_FIELD_ELEMENT_TYPES = /* @__PURE__ */ new Set([
   "e-form-date-picker",
   "e-form-time-picker",
   FORM_HIDDEN_FIELD_ELEMENT_TYPE,
-  FORM_HONEYPOT_ELEMENT_TYPE
+  FORM_HONEYPOT_ELEMENT_TYPE,
+  FORM_RECAPTCHA_SCORE_ELEMENT_TYPE
 ]);
 function getArgsElementType(args) {
   return args.model?.widgetType || args.model?.elType;
@@ -1899,112 +1901,128 @@ function handleBlockedFormField() {
   notify(FORM_FIELDS_OUTSIDE_ALERT);
 }
 
-// src/form-structure/hidden-field-hint.ts
+// src/form-structure/form-atom-added-hints.ts
 import { notify as notify2 } from "@elementor/editor-notifications";
 import { registerDataHook as registerDataHook3 } from "@elementor/editor-v1-adapters";
 import { __ as __2 } from "@wordpress/i18n";
 var MOVE_COMMAND = "document/elements/move";
+var FORM_ATOM_HINTS = {
+  [FORM_HONEYPOT_ELEMENT_TYPE]: {
+    idPrefix: "honeypot-added",
+    getMessage: () => __2("Honeypot added - invisible on your form. Reorder it in the Structure panel.", "elementor")
+  },
+  [FORM_RECAPTCHA_SCORE_ELEMENT_TYPE]: {
+    idPrefix: "recaptcha-score-added",
+    getMessage: () => __2("Score-based reCAPTCHA added - You can adjust its settings from the Structure panel.", "elementor")
+  }
+};
 var notificationCounter = 0;
-function createHiddenFieldNotification() {
-  return {
-    type: "default",
-    message: __2("Hidden field added - invisible on your form. Manage it in the Structure panel.", "elementor"),
-    id: `hidden-field-added-${++notificationCounter}`
-  };
-}
-function initHiddenFieldHint() {
+function initFormAtomAddedHints() {
   registerDataHook3("after", "document/elements/create", (args, _result, options) => {
     if (options?.commandsCurrentTrace?.includes(MOVE_COMMAND)) {
       return;
     }
-    if (getArgsElementType(args) === FORM_HIDDEN_FIELD_ELEMENT_TYPE) {
-      notify2(createHiddenFieldNotification());
+    const elementType = getArgsElementType(args);
+    const hint = elementType ? FORM_ATOM_HINTS[elementType] : void 0;
+    if (!hint) {
+      return;
     }
+    notify2({
+      type: "default",
+      message: hint.getMessage(),
+      id: `${hint.idPrefix}-${++notificationCounter}`
+    });
   });
 }
 
-// src/form-structure/honeypot-hint.ts
+// src/form-structure/hidden-field-hint.ts
 import { notify as notify3 } from "@elementor/editor-notifications";
 import { registerDataHook as registerDataHook4 } from "@elementor/editor-v1-adapters";
 import { __ as __3 } from "@wordpress/i18n";
 var MOVE_COMMAND2 = "document/elements/move";
 var notificationCounter2 = 0;
-function createHoneypotNotification() {
+function createHiddenFieldNotification() {
   return {
     type: "default",
-    message: __3("Honeypot added - invisible on your form. Reorder it in the Structure panel.", "elementor"),
-    id: `honeypot-added-${++notificationCounter2}`
+    message: __3("Hidden field added - invisible on your form. Manage it in the Structure panel.", "elementor"),
+    id: `hidden-field-added-${++notificationCounter2}`
   };
 }
-function initHoneypotHint() {
+function initHiddenFieldHint() {
   registerDataHook4("after", "document/elements/create", (args, _result, options) => {
     if (options?.commandsCurrentTrace?.includes(MOVE_COMMAND2)) {
       return;
     }
-    if (getArgsElementType(args) === FORM_HONEYPOT_ELEMENT_TYPE) {
-      notify3(createHoneypotNotification());
+    if (getArgsElementType(args) === FORM_HIDDEN_FIELD_ELEMENT_TYPE) {
+      notify3(createHiddenFieldNotification());
     }
   });
 }
 
-// src/form-structure/prevent-duplicate-honeypot-commands.ts
+// src/form-structure/prevent-duplicate-form-atoms-commands.ts
 import { getAllDescendants as getAllDescendants2 } from "@elementor/editor-elements";
 import { notify as notify4 } from "@elementor/editor-notifications";
 import { blockCommand as blockCommand2, registerDataHook as registerDataHook5 } from "@elementor/editor-v1-adapters";
 import { __ as __4 } from "@wordpress/i18n";
 var MOVE_COMMAND3 = "document/elements/move";
-var DUPLICATE_HONEYPOT_ALERT = {
-  type: "default",
-  message: __4("Only one Honeypot can be added per form.", "elementor"),
-  id: "duplicate-honeypot-blocked"
+var SINGLE_INSTANCE_FORM_ATOM_ALERTS = {
+  [FORM_HONEYPOT_ELEMENT_TYPE]: {
+    type: "default",
+    message: __4("Only one Honeypot can be added per form.", "elementor"),
+    id: "duplicate-honeypot-blocked"
+  },
+  [FORM_RECAPTCHA_SCORE_ELEMENT_TYPE]: {
+    type: "default",
+    message: __4("Only one Score-based reCAPTCHA can be added per form.", "elementor"),
+    id: "duplicate-recaptcha-score-blocked"
+  }
 };
-function initDuplicateHoneypotPrevention() {
+var SINGLE_INSTANCE_FORM_ATOM_TYPES = Object.keys(SINGLE_INSTANCE_FORM_ATOM_ALERTS);
+function initDuplicateFormAtomsPrevention() {
   registerDataHook5("dependency", "document/elements/create", (args, options) => {
-    return !blockHoneypotCreate(args, options);
+    return !blockDuplicateCreate(args, options);
   });
   blockCommand2({
     command: "document/elements/move",
-    condition: blockHoneypotMove
+    condition: blockDuplicateMove
   });
 }
-function blockHoneypotCreate(args, options) {
+function blockDuplicateCreate(args, options) {
   if (options?.commandsCurrentTrace?.includes(MOVE_COMMAND3)) {
     return false;
   }
-  if (!hasModelElementType(args.model, FORM_HONEYPOT_ELEMENT_TYPE)) {
-    return false;
-  }
   const containers = args.containers ?? [args.container];
-  if (containers.some((container) => formHasHoneypot(getFormContainer(container)))) {
-    handleBlockedHoneypot();
-    return true;
+  const blockedType = SINGLE_INSTANCE_FORM_ATOM_TYPES.find(
+    (type) => hasModelElementType(args.model, type) && containers.some((container) => formHasElementType(getFormContainer(container), type))
+  );
+  if (!blockedType) {
+    return false;
   }
-  return false;
+  notify4(SINGLE_INSTANCE_FORM_ATOM_ALERTS[blockedType]);
+  return true;
 }
-function blockHoneypotMove(args) {
+function blockDuplicateMove(args) {
   const { containers = [args.container], target } = args;
   const movedContainers = containers.filter((container) => !!container);
-  if (!movedContainers.some((container) => hasElementType(container, FORM_HONEYPOT_ELEMENT_TYPE))) {
-    return false;
-  }
   const movedElements = new Set(movedContainers.flatMap((container) => getAllDescendants2(container)));
-  if (formHasHoneypot(getFormContainer(target), movedElements)) {
-    handleBlockedHoneypot();
-    return true;
+  const targetForm = getFormContainer(target);
+  const blockedType = SINGLE_INSTANCE_FORM_ATOM_TYPES.find(
+    (type) => movedContainers.some((container) => hasElementType(container, type)) && formHasElementType(targetForm, type, movedElements)
+  );
+  if (!blockedType) {
+    return false;
   }
-  return false;
+  notify4(SINGLE_INSTANCE_FORM_ATOM_ALERTS[blockedType]);
+  return true;
 }
-function formHasHoneypot(form, excluded = /* @__PURE__ */ new Set()) {
+function formHasElementType(form, type, excluded = /* @__PURE__ */ new Set()) {
   if (!form) {
     return false;
   }
   return getAllDescendants2(form).some(
-    (element) => !excluded.has(element) && getElementType(element) === FORM_HONEYPOT_ELEMENT_TYPE
+    (element) => !excluded.has(element) && getElementType(element) === type
   );
 }
-function handleBlockedHoneypot() {
-  notify4(DUPLICATE_HONEYPOT_ALERT);
-}
 
 // src/form-structure/prevent-form-nesting-commands.ts
 import { notify as notify5 } from "@elementor/editor-notifications";
@@ -6085,8 +6103,8 @@ function init() {
   initFormNestingPrevention();
   initFormAncestorEnforcement();
   initHiddenFieldHint();
-  initDuplicateHoneypotPrevention();
-  initHoneypotHint();
+  initDuplicateFormAtomsPrevention();
+  initFormAtomAddedHints();
   initViewReplacements();
   initLegacyViews();
   initSettingsTransformers();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elementor/editor-canvas",
   "description": "Elementor Editor Canvas",
-  "version": "4.4.0-1144",
+  "version": "4.4.0-1145",
   "private": false,
   "author": "Elementor Team",
   "homepage": "https://elementor.com/",
@@ -37,26 +37,26 @@
     "react-dom": "^18.3.1"
   },
   "dependencies": {
-    "@elementor/editor": "4.4.0-1144",
-    "@elementor/editor-controls": "4.4.0-1144",
-    "@elementor/editor-documents": "4.4.0-1144",
-    "@elementor/editor-elements": "4.4.0-1144",
-    "@elementor/editor-interactions": "4.4.0-1144",
-    "@elementor/editor-mcp": "4.4.0-1144",
-    "@elementor/editor-notifications": "4.4.0-1144",
-    "@elementor/editor-props": "4.4.0-1144",
-    "@elementor/editor-responsive": "4.4.0-1144",
-    "@elementor/editor-styles": "4.4.0-1144",
-    "@elementor/editor-styles-repository": "4.4.0-1144",
-    "@elementor/editor-ui": "4.4.0-1144",
-    "@elementor/editor-v1-adapters": "4.4.0-1144",
-    "@elementor/events": "4.4.0-1144",
-    "@elementor/http-client": "4.4.0-1144",
-    "@elementor/schema": "4.4.0-1144",
-    "@elementor/twing": "4.4.0-1144",
+    "@elementor/editor": "4.4.0-1145",
+    "@elementor/editor-controls": "4.4.0-1145",
+    "@elementor/editor-documents": "4.4.0-1145",
+    "@elementor/editor-elements": "4.4.0-1145",
+    "@elementor/editor-interactions": "4.4.0-1145",
+    "@elementor/editor-mcp": "4.4.0-1145",
+    "@elementor/editor-notifications": "4.4.0-1145",
+    "@elementor/editor-props": "4.4.0-1145",
+    "@elementor/editor-responsive": "4.4.0-1145",
+    "@elementor/editor-styles": "4.4.0-1145",
+    "@elementor/editor-styles-repository": "4.4.0-1145",
+    "@elementor/editor-ui": "4.4.0-1145",
+    "@elementor/editor-v1-adapters": "4.4.0-1145",
+    "@elementor/events": "4.4.0-1145",
+    "@elementor/http-client": "4.4.0-1145",
+    "@elementor/schema": "4.4.0-1145",
+    "@elementor/twing": "4.4.0-1145",
     "@elementor/ui": "1.41.4",
-    "@elementor/utils": "4.4.0-1144",
-    "@elementor/wp-media": "4.4.0-1144",
+    "@elementor/utils": "4.4.0-1145",
+    "@elementor/wp-media": "4.4.0-1145",
     "@floating-ui/react": "^0.27.5",
     "@wordpress/i18n": "^5.13.0",
     "dompurify": "^3.2.6"

package/src/form-structure/__tests__/{honeypot-hint.test.ts → form-atom-added-hints.test.ts}

@@ -1,7 +1,7 @@
 import { createHooksRegistry, setupHooksRegistry } from 'test-utils';
 import { notify } from '@elementor/editor-notifications';
 
-import { initHoneypotHint } from '../honeypot-hint';
+import { initFormAtomAddedHints } from '../form-atom-added-hints';
 
 jest.mock( '@elementor/editor-notifications', () => ( {
 	notify: jest.fn(),
@@ -10,14 +10,45 @@ jest.mock( '@elementor/editor-notifications', () => ( {
 const CREATE_COMMAND = 'document/elements/create';
 const MOVE_COMMAND = 'document/elements/move';
 const HONEYPOT_TYPE = 'e-form-honeypot';
+const RECAPTCHA_SCORE_TYPE = 'e-form-recaptcha-score';
 
-describe( 'honeypot hint', () => {
+describe( 'form atom added hints', () => {
 	const hooksRegistry = createHooksRegistry();
 
 	beforeEach( () => {
 		jest.mocked( notify ).mockClear();
 		setupHooksRegistry( hooksRegistry );
-		initHoneypotHint();
+		initFormAtomAddedHints();
+	} );
+
+	it( 'should notify when a reCAPTCHA Score is added', () => {
+		// Arrange
+		const hook = hooksRegistry.getByCommand( CREATE_COMMAND );
+
+		// Act
+		hook?.apply( { model: { widgetType: RECAPTCHA_SCORE_TYPE } } );
+
+		// Assert
+		expect( notify ).toHaveBeenCalledWith(
+			expect.objectContaining( {
+				message: 'Score-based reCAPTCHA added - You can adjust its settings from the Structure panel.',
+			} )
+		);
+	} );
+
+	it( 'should notify again when a reCAPTCHA Score is removed and added once more', () => {
+		// Arrange
+		const hook = hooksRegistry.getByCommand( CREATE_COMMAND );
+
+		// Act
+		hook?.apply( { model: { widgetType: RECAPTCHA_SCORE_TYPE } } );
+		hook?.apply( { model: { widgetType: RECAPTCHA_SCORE_TYPE } } );
+
+		// Assert
+		expect( notify ).toHaveBeenCalledTimes( 2 );
+		expect( jest.mocked( notify ).mock.calls[ 0 ][ 0 ].id ).not.toBe(
+			jest.mocked( notify ).mock.calls[ 1 ][ 0 ].id
+		);
 	} );
 
 	it( 'should notify when a honeypot is added', () => {

package/src/form-structure/__tests__/{prevent-duplicate-honeypot-commands.test.ts → prevent-duplicate-form-atoms-commands.test.ts}

@@ -2,7 +2,7 @@ import { createHooksRegistry, setupHooksRegistry } from 'test-utils';
 import { type V1Element } from '@elementor/editor-elements';
 import { notify } from '@elementor/editor-notifications';
 
-import { initDuplicateHoneypotPrevention } from '../prevent-duplicate-honeypot-commands';
+import { initDuplicateFormAtomsPrevention } from '../prevent-duplicate-form-atoms-commands';
 
 jest.mock( '@elementor/editor-notifications', () => ( {
 	notify: jest.fn(),
@@ -11,6 +11,7 @@ jest.mock( '@elementor/editor-notifications', () => ( {
 const CREATE_COMMAND = 'document/elements/create';
 const MOVE_COMMAND = 'document/elements/move';
 const HONEYPOT_TYPE = 'e-form-honeypot';
+const RECAPTCHA_SCORE_TYPE = 'e-form-recaptcha-score';
 
 function createElement( type: string, children: V1Element[] = [] ): V1Element {
 	const element = {
@@ -26,7 +27,7 @@ function createElement( type: string, children: V1Element[] = [] ): V1Element {
 	return element;
 }
 
-describe( 'prevent duplicate honeypot', () => {
+describe( 'prevent duplicate form atoms', () => {
 	const hooksRegistry = createHooksRegistry();
 
 	const isAllowed = ( command: string, args: unknown ) => hooksRegistry.getByCommand( command )?.apply( args );
@@ -34,7 +35,7 @@ describe( 'prevent duplicate honeypot', () => {
 	beforeEach( () => {
 		jest.mocked( notify ).mockClear();
 		setupHooksRegistry( hooksRegistry );
-		initDuplicateHoneypotPrevention();
+		initDuplicateFormAtomsPrevention();
 	} );
 
 	it( 'should allow adding the first honeypot to a form', () => {
@@ -130,4 +131,68 @@ describe( 'prevent duplicate honeypot', () => {
 		expect( result ).toBe( false );
 		expect( notify ).toHaveBeenCalledTimes( 1 );
 	} );
+
+	it( 'should block a second reCAPTCHA Score in the same form and show its toast', () => {
+		// Arrange
+		const flexbox = createElement( 'e-flexbox' );
+		createElement( 'e-form', [ createElement( RECAPTCHA_SCORE_TYPE ), flexbox ] );
+
+		// Act
+		const result = isAllowed( CREATE_COMMAND, {
+			container: flexbox,
+			model: { widgetType: RECAPTCHA_SCORE_TYPE },
+		} );
+
+		// Assert
+		expect( result ).toBe( false );
+		expect( notify ).toHaveBeenCalledWith(
+			expect.objectContaining( { message: 'Only one Score-based reCAPTCHA can be added per form.' } )
+		);
+	} );
+
+	it( 'should allow a reCAPTCHA Score in a form that already has a honeypot', () => {
+		// Arrange
+		const form = createElement( 'e-form', [ createElement( HONEYPOT_TYPE ) ] );
+
+		// Act
+		const result = isAllowed( CREATE_COMMAND, { container: form, model: { widgetType: RECAPTCHA_SCORE_TYPE } } );
+
+		// Assert
+		expect( result ).toBe( true );
+		expect( notify ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should allow a reCAPTCHA Score in a second form on the same page', () => {
+		// Arrange
+		const secondForm = createElement( 'e-form' );
+		createElement( 'document', [
+			createElement( 'e-form', [ createElement( RECAPTCHA_SCORE_TYPE ) ] ),
+			secondForm,
+		] );
+
+		// Act
+		const result = isAllowed( CREATE_COMMAND, {
+			container: secondForm,
+			model: { widgetType: RECAPTCHA_SCORE_TYPE },
+		} );
+
+		// Assert
+		expect( result ).toBe( true );
+	} );
+
+	it( 'should block moving a reCAPTCHA Score into another form that already has one', () => {
+		// Arrange
+		const recaptcha = createElement( RECAPTCHA_SCORE_TYPE );
+		const targetForm = createElement( 'e-form', [ createElement( RECAPTCHA_SCORE_TYPE ) ] );
+		createElement( 'document', [ createElement( 'e-form', [ recaptcha ] ), targetForm ] );
+
+		// Act
+		const result = isAllowed( MOVE_COMMAND, { containers: [ recaptcha ], target: targetForm } );
+
+		// Assert
+		expect( result ).toBe( false );
+		expect( notify ).toHaveBeenCalledWith(
+			expect.objectContaining( { message: 'Only one Score-based reCAPTCHA can be added per form.' } )
+		);
+	} );
 } );

package/src/form-structure/form-atom-added-hints.ts

@@ -0,0 +1,53 @@
+import { notify } from '@elementor/editor-notifications';
+import { type HookOptions, registerDataHook } from '@elementor/editor-v1-adapters';
+import { __ } from '@wordpress/i18n';
+
+import {
+	type CreateArgs,
+	FORM_HONEYPOT_ELEMENT_TYPE,
+	FORM_RECAPTCHA_SCORE_ELEMENT_TYPE,
+	getArgsElementType,
+} from './utils';
+
+const MOVE_COMMAND = 'document/elements/move';
+
+type FormAtomHint = {
+	idPrefix: string;
+	getMessage: () => string;
+};
+
+const FORM_ATOM_HINTS: Record< string, FormAtomHint > = {
+	[ FORM_HONEYPOT_ELEMENT_TYPE ]: {
+		idPrefix: 'honeypot-added',
+		getMessage: () =>
+			__( 'Honeypot added - invisible on your form. Reorder it in the Structure panel.', 'elementor' ),
+	},
+	[ FORM_RECAPTCHA_SCORE_ELEMENT_TYPE ]: {
+		idPrefix: 'recaptcha-score-added',
+		getMessage: () =>
+			__( 'Score-based reCAPTCHA added - You can adjust its settings from the Structure panel.', 'elementor' ),
+	},
+};
+
+let notificationCounter = 0;
+
+export function initFormAtomAddedHints() {
+	registerDataHook( 'after', 'document/elements/create', ( args: CreateArgs, _result, options?: HookOptions ) => {
+		if ( options?.commandsCurrentTrace?.includes( MOVE_COMMAND ) ) {
+			return;
+		}
+
+		const elementType = getArgsElementType( args );
+		const hint = elementType ? FORM_ATOM_HINTS[ elementType ] : undefined;
+
+		if ( ! hint ) {
+			return;
+		}
+
+		notify( {
+			type: 'default',
+			message: hint.getMessage(),
+			id: `${ hint.idPrefix }-${ ++notificationCounter }`,
+		} );
+	} );
+}

package/src/form-structure/prevent-duplicate-form-atoms-commands.ts

@@ -0,0 +1,97 @@
+import { getAllDescendants, type V1Element } from '@elementor/editor-elements';
+import { type NotificationData, notify } from '@elementor/editor-notifications';
+import { blockCommand, type HookOptions, registerDataHook } from '@elementor/editor-v1-adapters';
+import { __ } from '@wordpress/i18n';
+
+import {
+	type CreateArgs,
+	FORM_HONEYPOT_ELEMENT_TYPE,
+	FORM_RECAPTCHA_SCORE_ELEMENT_TYPE,
+	getElementType,
+	getFormContainer,
+	hasElementType,
+	hasModelElementType,
+	type MoveArgs,
+} from './utils';
+
+const MOVE_COMMAND = 'document/elements/move';
+
+const SINGLE_INSTANCE_FORM_ATOM_ALERTS: Record< string, NotificationData > = {
+	[ FORM_HONEYPOT_ELEMENT_TYPE ]: {
+		type: 'default',
+		message: __( 'Only one Honeypot can be added per form.', 'elementor' ),
+		id: 'duplicate-honeypot-blocked',
+	},
+	[ FORM_RECAPTCHA_SCORE_ELEMENT_TYPE ]: {
+		type: 'default',
+		message: __( 'Only one Score-based reCAPTCHA can be added per form.', 'elementor' ),
+		id: 'duplicate-recaptcha-score-blocked',
+	},
+};
+
+const SINGLE_INSTANCE_FORM_ATOM_TYPES = Object.keys( SINGLE_INSTANCE_FORM_ATOM_ALERTS );
+
+export function initDuplicateFormAtomsPrevention() {
+	registerDataHook( 'dependency', 'document/elements/create', ( args: CreateArgs, options?: HookOptions ) => {
+		return ! blockDuplicateCreate( args, options );
+	} );
+
+	blockCommand( {
+		command: 'document/elements/move',
+		condition: blockDuplicateMove,
+	} );
+}
+
+function blockDuplicateCreate( args: CreateArgs, options?: HookOptions ): boolean {
+	// Move re-creates the moved element at the target, so it is handled by the move condition.
+	if ( options?.commandsCurrentTrace?.includes( MOVE_COMMAND ) ) {
+		return false;
+	}
+
+	const containers = args.containers ?? [ args.container ];
+
+	const blockedType = SINGLE_INSTANCE_FORM_ATOM_TYPES.find(
+		( type ) =>
+			hasModelElementType( args.model, type ) &&
+			containers.some( ( container ) => formHasElementType( getFormContainer( container ), type ) )
+	);
+
+	if ( ! blockedType ) {
+		return false;
+	}
+
+	notify( SINGLE_INSTANCE_FORM_ATOM_ALERTS[ blockedType ] );
+
+	return true;
+}
+
+function blockDuplicateMove( args: MoveArgs ): boolean {
+	const { containers = [ args.container ], target } = args;
+	const movedContainers = containers.filter( ( container ): container is V1Element => !! container );
+	const movedElements = new Set( movedContainers.flatMap( ( container ) => getAllDescendants( container ) ) );
+	const targetForm = getFormContainer( target );
+
+	const blockedType = SINGLE_INSTANCE_FORM_ATOM_TYPES.find(
+		( type ) =>
+			movedContainers.some( ( container ) => hasElementType( container, type ) ) &&
+			formHasElementType( targetForm, type, movedElements )
+	);
+
+	if ( ! blockedType ) {
+		return false;
+	}
+
+	notify( SINGLE_INSTANCE_FORM_ATOM_ALERTS[ blockedType ] );
+
+	return true;
+}
+
+function formHasElementType( form: V1Element | undefined, type: string, excluded: Set< V1Element > = new Set() ) {
+	if ( ! form ) {
+		return false;
+	}
+
+	return getAllDescendants( form ).some(
+		( element ) => ! excluded.has( element ) && getElementType( element ) === type
+	);
+}

package/src/form-structure/utils.ts

@@ -38,6 +38,7 @@ export type StorageContent = {
 export const FORM_ELEMENT_TYPE = 'e-form';
 export const FORM_HIDDEN_FIELD_ELEMENT_TYPE = 'e-form-hidden';
 export const FORM_HONEYPOT_ELEMENT_TYPE = 'e-form-honeypot';
+export const FORM_RECAPTCHA_SCORE_ELEMENT_TYPE = 'e-form-recaptcha-score';
 export const FORM_FIELD_ELEMENT_TYPES = new Set( [
 	'e-form-input',
 	'e-form-textarea',
@@ -51,6 +52,7 @@ export const FORM_FIELD_ELEMENT_TYPES = new Set( [
 	'e-form-time-picker',
 	FORM_HIDDEN_FIELD_ELEMENT_TYPE,
 	FORM_HONEYPOT_ELEMENT_TYPE,
+	FORM_RECAPTCHA_SCORE_ELEMENT_TYPE,
 ] );
 
 export function getArgsElementType( args: CreateArgs ): string | undefined {

package/src/init.tsx

@@ -6,9 +6,9 @@ import { ElementsOverlays } from './components/elements-overlays';
 import { InteractionsRenderer } from './components/interactions-renderer';
 import { StyleRenderer } from './components/style-renderer';
 import { initFormAncestorEnforcement } from './form-structure/enforce-form-ancestor-commands';
+import { initFormAtomAddedHints } from './form-structure/form-atom-added-hints';
 import { initHiddenFieldHint } from './form-structure/hidden-field-hint';
-import { initHoneypotHint } from './form-structure/honeypot-hint';
-import { initDuplicateHoneypotPrevention } from './form-structure/prevent-duplicate-honeypot-commands';
+import { initDuplicateFormAtomsPrevention } from './form-structure/prevent-duplicate-form-atoms-commands';
 import { initFormNestingPrevention } from './form-structure/prevent-form-nesting-commands';
 import { initSettingsTransformers } from './init-settings-transformers';
 import { initStyleTransformers } from './init-style-transformers';
@@ -29,8 +29,8 @@ export function init() {
 	initFormNestingPrevention();
 	initFormAncestorEnforcement();
 	initHiddenFieldHint();
-	initDuplicateHoneypotPrevention();
-	initHoneypotHint();
+	initDuplicateFormAtomsPrevention();
+	initFormAtomAddedHints();
 
 	initViewReplacements();
 

package/src/form-structure/honeypot-hint.ts

@@ -1,29 +0,0 @@
-import { type NotificationData, notify } from '@elementor/editor-notifications';
-import { type HookOptions, registerDataHook } from '@elementor/editor-v1-adapters';
-import { __ } from '@wordpress/i18n';
-
-import { type CreateArgs, FORM_HONEYPOT_ELEMENT_TYPE, getArgsElementType } from './utils';
-
-const MOVE_COMMAND = 'document/elements/move';
-
-let notificationCounter = 0;
-
-function createHoneypotNotification(): NotificationData {
-	return {
-		type: 'default',
-		message: __( 'Honeypot added - invisible on your form. Reorder it in the Structure panel.', 'elementor' ),
-		id: `honeypot-added-${ ++notificationCounter }`,
-	};
-}
-
-export function initHoneypotHint() {
-	registerDataHook( 'after', 'document/elements/create', ( args: CreateArgs, _result, options?: HookOptions ) => {
-		if ( options?.commandsCurrentTrace?.includes( MOVE_COMMAND ) ) {
-			return;
-		}
-
-		if ( getArgsElementType( args ) === FORM_HONEYPOT_ELEMENT_TYPE ) {
-			notify( createHoneypotNotification() );
-		}
-	} );
-}

package/src/form-structure/prevent-duplicate-honeypot-commands.ts

@@ -1,87 +0,0 @@
-import { getAllDescendants, type V1Element } from '@elementor/editor-elements';
-import { type NotificationData, notify } from '@elementor/editor-notifications';
-import { blockCommand, type HookOptions, registerDataHook } from '@elementor/editor-v1-adapters';
-import { __ } from '@wordpress/i18n';
-
-import {
-	type CreateArgs,
-	FORM_HONEYPOT_ELEMENT_TYPE,
-	getElementType,
-	getFormContainer,
-	hasElementType,
-	hasModelElementType,
-	type MoveArgs,
-} from './utils';
-
-const MOVE_COMMAND = 'document/elements/move';
-
-const DUPLICATE_HONEYPOT_ALERT: NotificationData = {
-	type: 'default',
-	message: __( 'Only one Honeypot can be added per form.', 'elementor' ),
-	id: 'duplicate-honeypot-blocked',
-};
-
-export function initDuplicateHoneypotPrevention() {
-	registerDataHook( 'dependency', 'document/elements/create', ( args: CreateArgs, options?: HookOptions ) => {
-		return ! blockHoneypotCreate( args, options );
-	} );
-
-	blockCommand( {
-		command: 'document/elements/move',
-		condition: blockHoneypotMove,
-	} );
-}
-
-function blockHoneypotCreate( args: CreateArgs, options?: HookOptions ): boolean {
-	// Move re-creates the moved element at the target, so it is handled by the move condition.
-	if ( options?.commandsCurrentTrace?.includes( MOVE_COMMAND ) ) {
-		return false;
-	}
-
-	if ( ! hasModelElementType( args.model, FORM_HONEYPOT_ELEMENT_TYPE ) ) {
-		return false;
-	}
-
-	const containers = args.containers ?? [ args.container ];
-
-	if ( containers.some( ( container ) => formHasHoneypot( getFormContainer( container ) ) ) ) {
-		handleBlockedHoneypot();
-
-		return true;
-	}
-
-	return false;
-}
-
-function blockHoneypotMove( args: MoveArgs ): boolean {
-	const { containers = [ args.container ], target } = args;
-	const movedContainers = containers.filter( ( container ): container is V1Element => !! container );
-
-	if ( ! movedContainers.some( ( container ) => hasElementType( container, FORM_HONEYPOT_ELEMENT_TYPE ) ) ) {
-		return false;
-	}
-
-	const movedElements = new Set( movedContainers.flatMap( ( container ) => getAllDescendants( container ) ) );
-
-	if ( formHasHoneypot( getFormContainer( target ), movedElements ) ) {
-		handleBlockedHoneypot();
-
-		return true;
-	}
-
-	return false;
-}
-
-function formHasHoneypot( form?: V1Element, excluded: Set< V1Element > = new Set() ): boolean {
-	if ( ! form ) {
-		return false;
-	}
-
-	return getAllDescendants( form ).some(
-		( element ) => ! excluded.has( element ) && getElementType( element ) === FORM_HONEYPOT_ELEMENT_TYPE
-	);
-}
-
-function handleBlockedHoneypot(): void {
-	notify( DUPLICATE_HONEYPOT_ALERT );
-}