first commit

wp-content/plugins/elementor/modules/global-classes/atomic-global-styles.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Plugin;
+use Elementor\Modules\AtomicWidgets\Styles\Atomic_Styles_Manager;
+
+class Atomic_Global_Styles {
+	const STYLES_KEY = 'global';
+
+	public function register_hooks() {
+		add_action(
+			'elementor/atomic-widgets/styles/register',
+			fn( Atomic_Styles_Manager $styles_manager ) => $this->register_styles( $styles_manager ),
+			20,
+			2
+		);
+
+		add_action( 'elementor/global_classes/update', fn( string $context ) => $this->invalidate_cache( $context ), 10, 1 );
+
+		add_action(
+			'deleted_post',
+			fn( $post_id ) => $this->on_post_delete( $post_id )
+		);
+
+		add_action(
+			'elementor/core/files/clear_cache',
+			fn() => $this->invalidate_cache(),
+		);
+
+		add_filter('elementor/atomic-widgets/settings/transformers/classes',
+			fn( $value ) => $this->transform_classes_names( $value )
+		);
+	}
+
+	private function register_styles( Atomic_Styles_Manager $styles_manager ) {
+		$context = is_preview() ? Global_Classes_Repository::CONTEXT_PREVIEW : Global_Classes_Repository::CONTEXT_FRONTEND;
+
+		$get_styles = function () use ( $context ) {
+			return Global_Classes_Repository::make()->context( $context )->all()->get_items()->map( function( $item ) {
+				$item['id'] = $item['label'];
+				return $item;
+			})->all();
+		};
+
+		$styles_manager->register(
+			[ self::STYLES_KEY, $context ],
+			$get_styles,
+		);
+	}
+
+	private function on_post_delete( $post_id ) {
+		if ( ! Plugin::$instance->kits_manager->is_kit( $post_id ) ) {
+			return;
+		}
+
+		$this->invalidate_cache();
+	}
+
+	private function invalidate_cache( ?string $context = null ) {
+		if ( empty( $context ) || Global_Classes_Repository::CONTEXT_FRONTEND === $context ) {
+			do_action( 'elementor/atomic-widgets/styles/clear', [ self::STYLES_KEY ] );
+
+			return;
+		}
+
+		do_action( 'elementor/atomic-widgets/styles/clear', [ self::STYLES_KEY, $context ] );
+	}
+
+	private function transform_classes_names( $ids ) {
+		$context = is_preview() ? Global_Classes_Repository::CONTEXT_PREVIEW : Global_Classes_Repository::CONTEXT_FRONTEND;
+
+		$classes = Global_Classes_Repository::make()
+			->context( $context )
+			->all()
+			->get_items();
+
+		return array_map(
+			function( $id ) use ( $classes ) {
+				$class = $classes->get( $id );
+
+				return $class ? $class['label'] : $id;
+			},
+			$ids
+		);
+	}
+}

wp-content/plugins/elementor/modules/global-classes/database/global-classes-database-updater.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Database;
+
+use Elementor\Core\Database\Base_Database_Updater;
+use Elementor\Modules\GlobalClasses\Database\Migrations\Add_Capabilities;
+
+class Global_Classes_Database_Updater extends Base_Database_Updater {
+	const DB_VERSION = 1;
+	const OPTION_NAME = 'elementor_global_classes_db_version';
+
+	protected function get_migrations(): array {
+		return [
+			1 => new Add_Capabilities(),
+		];
+	}
+
+	protected function get_db_version() {
+		return static::DB_VERSION;
+	}
+
+	protected function get_db_version_option_name(): string {
+		return static::OPTION_NAME;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/database/migrations/add-capabilities.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Database\Migrations;
+
+use Elementor\Core\Database\Base_Migration;
+
+class Add_Capabilities extends Base_Migration {
+	const UPDATE_CLASS = 'elementor_global_classes_update_class';
+	const REMOVE_CSS_CLASS = 'elementor_global_classes_remove_class';
+	const APPLY_CSS_CLASS = 'elementor_global_classes_apply_class';
+
+	public function up() {
+		$capabilities = [
+			self::UPDATE_CLASS              => [ 'administrator' ],
+			self::REMOVE_CSS_CLASS          => [ 'administrator', 'editor', 'author', 'contributor', 'shop_manager' ],
+			self::APPLY_CSS_CLASS           => [ 'administrator', 'editor', 'author', 'contributor', 'shop_manager' ],
+		];
+
+		foreach ( $capabilities as $capability => $roles ) {
+			foreach ( $roles as $role_name ) {
+				$role = get_role( $role_name );
+
+				if ( $role ) {
+					$role->add_cap( $capability );
+				}
+			}
+		}
+	}
+}

wp-content/plugins/elementor/modules/global-classes/global-classes-changes-resolver.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Core\Utils\Collection;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Global_Classes_Changes_Resolver {
+	private Global_Classes_Repository $repository;
+
+	private Collection $added;
+
+	private Collection $deleted;
+
+	private Collection $modified;
+
+	public function __construct( Global_Classes_Repository $repository, array $changes ) {
+		$this->repository = $repository;
+		$this->added = Collection::make( $changes['added'] ?? [] );
+		$this->deleted = Collection::make( $changes['deleted'] ?? [] );
+		$this->modified = Collection::make( $changes['modified'] ?? [] );
+	}
+
+	public static function make( Global_Classes_Repository $repository, array $changes ): self {
+		return new self( $repository, $changes );
+	}
+
+	public function resolve_items( array $payload ) {
+		$touched = $this->added->merge( $this->modified )->values();
+
+		$items_to_save = Collection::make( $payload )->only( $touched );
+
+		return $this->repository
+			->all()
+			->get_items()
+			->except( $this->deleted->values() )
+			->merge( $items_to_save )
+			->all();
+	}
+
+	public function resolve_order( array $payload ) {
+		$payload = Collection::make( $payload );
+
+		$current_order = $this->repository->all()->get_order();
+
+		$missing_in_current_order = $payload
+			->filter( fn( $item ) => ! $this->added->contains( $item ) )
+			->diff( $current_order );
+
+		$payload = $payload->filter( fn( $item ) => ! $missing_in_current_order->contains( $item ) );
+
+		$missing_in_payload = $current_order
+			->filter( fn( $item ) => ! $this->deleted->contains( $item ) )
+			->diff( $payload );
+
+		return $missing_in_payload
+			->merge( $payload )
+			->all();
+	}
+}

wp-content/plugins/elementor/modules/global-classes/global-classes-cleanup.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Core\Base\Document;
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\AtomicWidgets\Elements\Base\Atomic_Element_Base;
+use Elementor\Modules\AtomicWidgets\Elements\Base\Atomic_Widget_Base;
+use Elementor\Modules\GlobalClasses\Utils\Atomic_Elements_Utils;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Global_Classes_Cleanup {
+
+	public function register_hooks() {
+		add_action(
+			'elementor/global_classes/update',
+			fn( $context, $new_value, $prev_value ) => $this->on_classes_update( $new_value, $prev_value ),
+			10,
+			3
+		);
+	}
+
+	private function on_classes_update( $new_value, $prev_value ) {
+		$deleted_classes_ids = $this->get_deleted_classes_ids( $new_value, $prev_value );
+		$additional_post_types = apply_filters( 'elementor/global_classes/additional_post_types', [] );
+
+		if ( ! empty( $deleted_classes_ids ) ) {
+			Plugin::$instance->db->iterate_elementor_documents(
+				fn( $document, $elements_data ) => $this->unapply_deleted_classes( $document, $elements_data, $deleted_classes_ids ),
+				100,
+				$additional_post_types
+			);
+		}
+	}
+
+	private function get_deleted_classes_ids( $new_value, $prev_value ) {
+		$prev_ids = array_keys( $prev_value['items'] );
+		$new_ids = array_keys( $new_value['items'] );
+
+		return array_values(
+			array_diff( $prev_ids, $new_ids )
+		);
+	}
+
+	private function unapply_deleted_classes( $document, $elements_data, $deleted_classes_ids ) {
+		$elements_data = Plugin::$instance->db->iterate_data( $elements_data, function( $element_data ) use ( $deleted_classes_ids ) {
+			$element_type = Atomic_Elements_Utils::get_element_type( $element_data );
+			$element_instance = Atomic_Elements_Utils::get_element_instance( $element_type );
+
+			if ( ! Atomic_Elements_Utils::is_atomic_element( $element_instance ) ) {
+				return $element_data;
+			}
+
+			/** @var Atomic_Element_Base | Atomic_Widget_Base $element_instance */
+			return $this->unapply_classes_from_element( $element_instance->get_props_schema(), $element_data, $deleted_classes_ids );
+		} );
+
+		$document->update_json_meta( Document::ELEMENTOR_DATA_META_KEY, $elements_data );
+	}
+
+	private function unapply_classes_from_element( $props_schema, $element_data, $deleted_classes_ids ) {
+		foreach ( $props_schema as $prop ) {
+			if ( ! Atomic_Elements_Utils::is_classes_prop( $prop ) ) {
+				continue;
+			}
+
+			$current_classes = $element_data['settings'][ $prop->get_key() ] ?? null;
+
+			if ( ! $current_classes ) {
+				continue;
+			}
+
+			$element_data['settings'][ $prop->get_key() ]['value'] = Collection::make( $current_classes['value'] )
+				->filter( fn( $class_name ) => ! in_array( $class_name, $deleted_classes_ids, true ) )
+				->values();
+		}
+
+		return $element_data;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/global-classes-parser.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\AtomicWidgets\Module;
+use Elementor\Modules\AtomicWidgets\OptIn\Opt_In;
+use Elementor\Core\Utils\Api\Parse_Result;
+use Elementor\Modules\AtomicWidgets\Parsers\Style_Parser;
+use Elementor\Modules\AtomicWidgets\Styles\Style_Schema;
+
+class Global_Classes_Parser {
+	public static function make() {
+		return new static();
+	}
+
+	public function parse( $data ): Parse_Result {
+		$result = Parse_Result::make();
+
+		if ( ! isset( $data['items'] ) ) {
+			$result->errors()->add( 'items', 'missing' );
+
+			return $result;
+		}
+
+		if ( ! isset( $data['order'] ) ) {
+			$result->errors()->add( 'order', 'missing' );
+
+			return $result;
+		}
+
+		$items = $data['items'];
+		$order = $data['order'];
+
+		if ( ! is_array( $items ) ) {
+			$result->errors()->add( 'items', 'invalid' );
+
+			return $result;
+		}
+
+		if ( ! is_array( $order ) ) {
+			$result->errors()->add( 'order', 'invalid' );
+
+			return $result;
+		}
+
+		$items_result = $this->parse_items( $items );
+
+		if ( ! $items_result->is_valid() ) {
+			$result->errors()->merge( $items_result->errors(), 'items' );
+
+			return $result;
+		}
+
+		$order_result = $this->parse_order( $order, $items_result->unwrap() );
+
+		if ( ! $order_result->is_valid() ) {
+			$result->errors()->merge( $order_result->errors(), 'order' );
+
+			return $result;
+		}
+
+		return $result->wrap( [
+			'items' => $items_result->unwrap(),
+			'order' => $order_result->unwrap(),
+		] );
+	}
+
+	public function parse_items( array $items ) {
+		$sanitized_items = [];
+		$result = Parse_Result::make();
+		$style_parser = Style_Parser::make( Style_Schema::get() );
+		$existing_labels = [];
+
+		foreach ( $items as $item_id => $item ) {
+			$item_result = $style_parser->parse( $item );
+
+			if ( ! $item_result->is_valid() ) {
+				$result->errors()->merge( $item_result->errors(), $item_id );
+
+				continue;
+			}
+
+			$sanitized_item = $item_result->unwrap();
+
+			if ( $item_id !== $sanitized_item['id'] ) {
+				$result->errors()->add( "$item_id.id", 'mismatching_value' );
+
+				continue;
+			}
+
+			$sanitized_items[ $sanitized_item['id'] ] = $sanitized_item;
+			$existing_labels[] = $sanitized_item['label'];
+		}
+
+		return $result->wrap( $sanitized_items );
+	}
+
+	public function parse_order( array $order, array $items ): Parse_Result {
+		$result = Parse_Result::make();
+
+		$items = Collection::make( $items );
+
+		$order = Collection::make( $order )
+			->filter( fn( $item ) => is_string( $item ) )
+			->unique();
+
+		$existing_ids = $items->keys();
+
+		$excess_ids = $order->diff( $existing_ids );
+		$missing_ids = $existing_ids->diff( $order );
+
+		$excess_ids->each( fn( $id ) => $result->errors()->add( $id, 'excess' ) );
+		$missing_ids->each( fn( $id ) => $result->errors()->add( $id, 'missing' ) );
+
+		return $result->is_valid()
+			? $result->wrap( $order->values() )
+			: $result;
+	}
+
+	public static function check_for_duplicate_labels( array $existing_labels, array $items, array $new_items_ids ) {
+
+		if ( empty( $new_items_ids ) ) {
+			return false;
+		}
+		$new_added_items = array_filter( $items, fn( $item ) => in_array( $item['id'], $new_items_ids, true ) );
+
+		$duplicates = [];
+
+		foreach ( $new_added_items as $item_id => $item ) {
+			if ( in_array( $item['label'], $existing_labels, true ) ) {
+				$duplicates[] = [
+					'item_id' => $item_id,
+					'label' => $item['label'],
+				];
+			}
+		}
+		return $duplicates;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/global-classes-repository.php

@@ -0,0 +1,87 @@
+<?php
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Core\Base\Document;
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\AtomicWidgets\Elements\Base\Atomic_Element_Base;
+use Elementor\Modules\AtomicWidgets\Elements\Base\Atomic_Widget_Base;
+use Elementor\Modules\GlobalClasses\Utils\Atomic_Elements_Utils;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Global_Classes_Repository {
+
+	const META_KEY_FRONTEND = '_elementor_global_classes';
+	const META_KEY_PREVIEW = '_elementor_global_classes_preview';
+
+	const CONTEXT_FRONTEND = 'frontend';
+	const CONTEXT_PREVIEW = 'preview';
+
+	private string $context = self::CONTEXT_FRONTEND;
+
+	public static function make(): Global_Classes_Repository {
+		return new self();
+	}
+
+	public function context( string $context ): self {
+		$this->context = $context;
+
+		return $this;
+	}
+
+	public function all() {
+		$meta_key = $this->get_meta_key();
+		$all = $this->get_kit()->get_json_meta( $meta_key );
+
+		$is_preview = static::META_KEY_PREVIEW === $meta_key;
+		$is_empty = empty( $all );
+
+		if ( $is_preview && $is_empty ) {
+			$all = $this->get_kit()->get_json_meta( static::META_KEY_FRONTEND );
+		}
+
+		return Global_Classes::make( $all['items'] ?? [], $all['order'] ?? [] );
+	}
+
+	public function put( array $items, array $order ) {
+		$current_value = $this->all()->get();
+
+		$updated_value = [
+			'items' => $items,
+			'order' => $order,
+		];
+
+		// `update_metadata` fails for identical data, so we skip it.
+		if ( $current_value === $updated_value ) {
+			return;
+		}
+
+		$meta_key = $this->get_meta_key();
+		$value = $this->get_kit()->update_json_meta( $meta_key, $updated_value );
+
+		$should_delete_preview = static::META_KEY_FRONTEND === $meta_key;
+
+		if ( $should_delete_preview ) {
+			$this->get_kit()->delete_meta( static::META_KEY_PREVIEW );
+		}
+
+		if ( ! $value ) {
+			throw new \Exception( 'Failed to update global classes' );
+		}
+
+		do_action( 'elementor/global_classes/update', $this->context, $updated_value, $current_value );
+	}
+
+	private function get_meta_key(): string {
+		return static::CONTEXT_FRONTEND === $this->context
+			? static::META_KEY_FRONTEND
+			: static::META_KEY_PREVIEW;
+	}
+
+	private function get_kit() {
+		return Plugin::$instance->kits_manager->get_active_kit();
+	}
+}

wp-content/plugins/elementor/modules/global-classes/global-classes-rest-api.php

@@ -0,0 +1,339 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Modules\GlobalClasses\Usage\Applied_Global_Classes_Usage;
+use Elementor\Core\Utils\Api\Error_Builder;
+use Elementor\Core\Utils\Api\Response_Builder;
+use Elementor\Modules\GlobalClasses\Database\Migrations\Add_Capabilities;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Global_Classes_REST_API {
+	const API_NAMESPACE = 'elementor/v1';
+	const API_BASE = 'global-classes';
+	const API_BASE_USAGE = self::API_BASE . '/usage';
+	const MAX_ITEMS = 100;
+	const LABEL_PREFIX = 'DUP_';
+	const MAX_LABEL_LENGTH = 50;
+	private $repository = null;
+
+	public function register_hooks() {
+		add_action( 'rest_api_init', fn() => $this->register_routes() );
+	}
+
+	private function get_repository() {
+		if ( ! $this->repository ) {
+			$this->repository = new Global_Classes_Repository();
+		}
+
+		return $this->repository;
+	}
+
+	private function register_routes() {
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE, [
+			[
+				'methods' => 'GET',
+				'callback' => fn( $request ) => $this->route_wrapper( fn() => $this->all( $request ) ),
+				'permission_callback' => fn() => is_user_logged_in(),
+				'args' => [
+					'context' => [
+						'type' => 'string',
+						'required' => false,
+						'default' => Global_Classes_Repository::CONTEXT_FRONTEND,
+						'enum' => [
+							Global_Classes_Repository::CONTEXT_FRONTEND,
+							Global_Classes_Repository::CONTEXT_PREVIEW,
+						],
+					],
+				],
+			],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE_USAGE, [
+			[
+				'callback' => fn() => $this->route_wrapper( fn() => $this->get_usage() ),
+				'permission_callback' => fn() => current_user_can( 'manage_options' ),
+				'args' => [
+					'context' => [
+						'type' => 'string',
+						'required' => false,
+						'default' => Global_Classes_Repository::CONTEXT_FRONTEND,
+						'enum' => [
+							Global_Classes_Repository::CONTEXT_FRONTEND,
+							Global_Classes_Repository::CONTEXT_PREVIEW,
+						],
+					],
+				],
+			],
+		] );
+
+		register_rest_route( self::API_NAMESPACE, '/' . self::API_BASE, [
+			[
+				'methods' => 'PUT',
+				'callback' => fn( $request ) => $this->route_wrapper( fn() => $this->put( $request ) ),
+				'permission_callback' => fn() => current_user_can( Add_Capabilities::UPDATE_CLASS ),
+				'args' => [
+					'context' => [
+						'type' => 'string',
+						'required' => false,
+						'default' => Global_Classes_Repository::CONTEXT_FRONTEND,
+						'enum' => [
+							Global_Classes_Repository::CONTEXT_FRONTEND,
+							Global_Classes_Repository::CONTEXT_PREVIEW,
+						],
+					],
+					'changes' => [
+						'type' => 'object',
+						'required' => true,
+						'additionalProperties' => false,
+						'properties' => [
+							'added' => [
+								'type' => 'array',
+								'required' => true,
+								'items' => [ 'type' => 'string' ],
+							],
+							'deleted' => [
+								'type' => 'array',
+								'required' => true,
+								'items' => [ 'type' => 'string' ],
+							],
+							'modified' => [
+								'type' => 'array',
+								'required' => true,
+								'items' => [ 'type' => 'string' ],
+							],
+						],
+					],
+					'items' => [
+						'required' => true,
+						'type' => 'object',
+						'additionalProperties' => [
+							'type' => 'object',
+							'properties' => [
+								'id' => [
+									'type' => 'string',
+									'required' => true,
+								],
+								'variants' => [
+									'type' => 'array',
+									'required' => true,
+								],
+								'type' => [
+									'type' => 'string',
+									'enum' => [ 'class' ],
+									'required' => true,
+								],
+								'label' => [
+									'type' => 'string',
+									'required' => true,
+								],
+							],
+						],
+					],
+					'order' => [
+						'required' => true,
+						'type' => 'array',
+						'items' => [
+							'type' => 'string',
+						],
+					],
+				],
+			],
+		] );
+	}
+
+	private function all( \WP_REST_Request $request ) {
+		$context = $request->get_param( 'context' );
+
+		$classes = $this->get_repository()->context( $context )->all();
+
+		return Response_Builder::make( (object) $classes->get_items()->all() )
+			->set_meta( [ 'order' => $classes->get_order()->all() ] )
+			->build();
+	}
+
+	private function get_usage() {
+		$classes_usage = ( new Applied_Global_Classes_Usage() )->get_detailed_usage();
+
+		return Response_Builder::make( (object) $classes_usage )->build();
+	}
+
+	private function put( \WP_REST_Request $request ) {
+		$context = $request->get_param( 'context' );
+		$changes = $request->get_param( 'changes' ) ?? [];
+		$new_added_items_ids = $changes['added'] ?? [];
+		$parser = Global_Classes_Parser::make();
+		$existing_labels = Global_Classes_Repository::make()
+			->context( $context )
+			->all()
+			->get_items()
+			->map( function ( $item ) {
+				return $item['label'];
+			} )
+		->all();
+
+		$items_result = $parser->parse_items(
+			$request->get_param( 'items' )
+		);
+
+		$items_count = count( $items_result->unwrap() );
+
+		if ( $items_count > self::MAX_ITEMS ) {
+			return Error_Builder::make( 'global_classes_limit_exceeded' )
+				->set_status( 400 )
+				->set_meta([
+					'current_count' => $items_count,
+					'max_allowed' => self::MAX_ITEMS,
+				])
+				->set_message(sprintf(
+					/* translators: %d: Maximum allowed items. */
+					__( 'Global classes limit exceeded. Maximum allowed: %d', 'elementor' ),
+					self::MAX_ITEMS
+				))
+				->build();
+		}
+
+		if ( ! $items_result->is_valid() ) {
+			return Error_Builder::make( 'invalid_items' )
+				->set_status( 400 )
+				->set_message( 'Invalid items: ' . $items_result->errors()->to_string() )
+				->build();
+		}
+
+		$order_result = $parser->parse_order(
+			$request->get_param( 'order' ),
+			$items_result->unwrap()
+		);
+
+		if ( ! $order_result->is_valid() ) {
+			return Error_Builder::make( 'invalid_order' )
+				->set_status( 400 )
+				->set_message( 'Invalid order: ' . $order_result->errors()->to_string() )
+				->build();
+		}
+
+		$repository = $this->get_repository()
+			->context( $request->get_param( 'context' ) );
+
+		$changes_resolver = Global_Classes_Changes_Resolver::make(
+			$repository,
+			$changes,
+		);
+
+		$duplicated_labels = Global_Classes_Parser::check_for_duplicate_labels(
+			$existing_labels,
+			$items_result->unwrap(),
+			$new_added_items_ids
+		);
+
+		$final_items = $items_result->unwrap();
+		$duplicate_validation_result = null;
+
+		if ( ! empty( $duplicated_labels ) ) {
+			$modified_labels = $this->handle_duplicates( $duplicated_labels, $existing_labels );
+			$duplicate_validation_result = $modified_labels;
+			foreach ( $modified_labels as $item_id => $labels ) {
+					$final_items[ $item_id ]['label'] = $labels['modified'];
+			}
+		}
+
+		$repository->put(
+			$changes_resolver->resolve_items( $final_items ),
+			$changes_resolver->resolve_order( $order_result->unwrap() ),
+		);
+
+		if ( $duplicate_validation_result ) {
+			$response_data = [
+				'code' => 'DUPLICATED_LABEL',
+				'modifiedLabels' => $duplicate_validation_result,
+			];
+			return Response_Builder::make( $response_data )->build();
+		}
+
+		return Response_Builder::make()->no_content()->build();
+	}
+
+	private function route_wrapper( callable $cb ) {
+		try {
+			$response = $cb();
+		} catch ( \Exception $e ) {
+			return Error_Builder::make( 'unexpected_error' )
+				->set_message( __( 'Something went wrong', 'elementor' ) )
+				->build();
+		}
+
+		return $response;
+	}
+
+	private function handle_duplicates( array $duplicate_labels, array $existing_labels ) {
+
+		$modified_labels = [];
+
+		foreach ( $duplicate_labels as $duplicate_label ) {
+			$item_id = $duplicate_label['item_id'];
+			$original_label = $duplicate_label['label'];
+
+			$modified_label = $this->generate_unique_label( $original_label, $existing_labels );
+
+			$modified_labels[ $item_id ] = [
+				'original' => $original_label,
+				'modified' => $modified_label,
+			];
+		}
+
+		return $modified_labels;
+	}
+
+
+	private function generate_unique_label( $original_label, $existing_labels ) {
+		$prefix = self::LABEL_PREFIX;
+		$max_length = self::MAX_LABEL_LENGTH;
+
+		$has_prefix = strpos( $original_label, $prefix ) === 0;
+
+		if ( $has_prefix ) {
+			$base_label = substr( $original_label, strlen( $prefix ) );
+
+			$counter = 1;
+			$new_label = $prefix . $base_label . $counter;
+
+			while ( in_array( $new_label, $existing_labels, true ) ) {
+				++$counter;
+				$new_label = $prefix . $base_label . $counter;
+			}
+
+			if ( strlen( $new_label ) > $max_length ) {
+				$available_length = $max_length - strlen( $prefix . $counter );
+				$base_label = substr( $base_label, 0, $available_length );
+				$new_label = $prefix . $base_label . $counter;
+			}
+		} else {
+			$new_label = $prefix . $original_label;
+
+			if ( strlen( $new_label ) > $max_length ) {
+				$available_length = $max_length - strlen( $prefix );
+				$new_label = $prefix . substr( $original_label, 0, $available_length );
+			}
+
+			$counter = 1;
+			$base_label = substr( $original_label, 0, $available_length ?? strlen( $original_label ) );
+
+			while ( in_array( $new_label, $existing_labels, true ) ) {
+				$new_label = $prefix . $base_label . $counter;
+
+				if ( strlen( $new_label ) > $max_length ) {
+					$available_length = $max_length - strlen( $prefix . $counter );
+					$base_label = substr( $original_label, 0, $available_length );
+					$new_label = $prefix . $base_label . $counter;
+				}
+
+				++$counter;
+			}
+		}
+
+		return $new_label;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/global-classes.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Core\Utils\Collection;
+
+class Global_Classes {
+	private Collection $items;
+	private Collection $order;
+
+	public static function make( array $items = [], array $order = [] ) {
+		return new static( $items, $order );
+	}
+
+	private function __construct( array $data = [], array $order = [] ) {
+		$this->items = Collection::make( $data );
+		$this->order = Collection::make( $order );
+	}
+
+	public function get_items() {
+		return $this->items;
+	}
+
+	public function get_order() {
+		return $this->order;
+	}
+
+	public function get() {
+		return [
+			'items' => $this->get_items()->all(),
+			'order' => $this->get_order()->all(),
+		];
+	}
+}

wp-content/plugins/elementor/modules/global-classes/import-export-customization/import-export-customization.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\ImportExportCustomization;
+
+use Elementor\App\Modules\ImportExportCustomization\Processes\Export;
+use Elementor\App\Modules\ImportExportCustomization\Processes\Import;
+use Elementor\Modules\GlobalClasses\ImportExportCustomization\Runners\Export as Export_Runner;
+use Elementor\Modules\GlobalClasses\ImportExportCustomization\Runners\Import as Import_Runner;
+
+class Import_Export_Customization {
+	const FILE_NAME = 'global-classes';
+
+	public function register_hooks() {
+		add_action( 'elementor/import-export-customization/export-kit', function ( Export $export ) {
+			$export->register( new Export_Runner() );
+		} );
+
+		add_action( 'elementor/import-export-customization/import-kit', function ( Import $import ) {
+			$import->register( new Import_Runner() );
+		} );
+	}
+}

wp-content/plugins/elementor/modules/global-classes/import-export-customization/runners/export.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\ImportExportCustomization\Runners;
+
+use Elementor\App\Modules\ImportExportCustomization\Runners\Export\Export_Runner_Base;
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+use Elementor\Modules\GlobalClasses\Global_Classes_Parser;
+use Elementor\Modules\GlobalClasses\ImportExportCustomization\Import_Export_Customization;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Export extends Export_Runner_Base {
+	public static function get_name(): string {
+		return 'global-classes';
+	}
+
+	public function should_export( array $data ) {
+		// Same as the site-settings runner.
+		return (
+			isset( $data['include'] ) &&
+			in_array( 'settings', $data['include'], true )
+		);
+	}
+
+	public function export( array $data ) {
+		$kit = Plugin::$instance->kits_manager->get_active_kit();
+
+		if ( ! $kit ) {
+			return [
+				'manifest' => [],
+				'files' => [],
+			];
+		}
+
+		$global_classes = Global_Classes_Repository::make()->all()->get();
+
+		$global_classes_result = Global_Classes_Parser::make()->parse( $global_classes );
+
+		if ( ! $global_classes_result->is_valid() ) {
+			return [
+				'manifest' => [],
+				'files' => [],
+			];
+		}
+
+		return [
+			'files' => [
+				'path' => Import_Export_Customization::FILE_NAME,
+				'data' => $global_classes_result->unwrap(),
+			],
+			'manifest' => [],
+		];
+	}
+}

wp-content/plugins/elementor/modules/global-classes/import-export-customization/runners/import.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\ImportExportCustomization\Runners;
+
+use Elementor\App\Modules\ImportExportCustomization\Runners\Import\Import_Runner_Base;
+use Elementor\App\Modules\ImportExportCustomization\Utils as ImportExportUtils;
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+use Elementor\Modules\GlobalClasses\Global_Classes_Parser;
+use Elementor\Modules\GlobalClasses\ImportExportCustomization\Import_Export_Customization;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Import extends Import_Runner_Base {
+	public static function get_name(): string {
+		return 'global-classes';
+	}
+
+	public function should_import( array $data ) {
+		// Same as the site-settings runner.
+		return (
+			isset( $data['include'] ) &&
+			in_array( 'settings', $data['include'], true ) &&
+			! empty( $data['site_settings']['settings'] ) &&
+			! empty( $data['extracted_directory_path'] )
+		);
+	}
+
+	public function import( array $data, array $imported_data ) {
+		$kit = Plugin::$instance->kits_manager->get_active_kit();
+
+		$file_name = Import_Export_Customization::FILE_NAME;
+		$global_classes = ImportExportUtils::read_json_file( "{$data['extracted_directory_path']}/{$file_name}.json" );
+
+		if ( ! $kit || ! $global_classes ) {
+			return [];
+		}
+
+		$global_classes_result = Global_Classes_Parser::make()->parse( $global_classes );
+
+		if ( ! $global_classes_result->is_valid() ) {
+			return [];
+		}
+
+		$global_classes = $global_classes_result->unwrap();
+
+		Global_Classes_Repository::make()->put(
+			$global_classes['items'],
+			$global_classes['order']
+		);
+
+		return $global_classes;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/import-export/export-runner.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\ImportExport;
+
+use Elementor\App\Modules\ImportExport\Runners\Export\Export_Runner_Base;
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+use Elementor\Modules\GlobalClasses\Global_Classes_Parser;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Export_Runner extends Export_Runner_Base {
+	public static function get_name(): string {
+		return 'global-classes';
+	}
+
+	public function should_export( array $data ) {
+		// Same as the site-settings runner.
+		return (
+			isset( $data['include'] ) &&
+			in_array( 'settings', $data['include'], true )
+		);
+	}
+
+	public function export( array $data ) {
+		$kit = Plugin::$instance->kits_manager->get_active_kit();
+
+		if ( ! $kit ) {
+			return [
+				'manifest' => [],
+				'files' => [],
+			];
+		}
+
+		$global_classes = Global_Classes_Repository::make()->all()->get();
+
+		$global_classes_result = Global_Classes_Parser::make()->parse( $global_classes );
+
+		if ( ! $global_classes_result->is_valid() ) {
+			return [
+				'manifest' => [],
+				'files' => [],
+			];
+		}
+
+		return [
+			'files' => [
+				'path' => Import_Export::FILE_NAME,
+				'data' => $global_classes_result->unwrap(),
+			],
+		];
+	}
+}

wp-content/plugins/elementor/modules/global-classes/import-export/import-export.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\ImportExport;
+
+use Elementor\App\Modules\ImportExport\Processes\Export;
+use Elementor\App\Modules\ImportExport\Processes\Import;
+
+class Import_Export {
+	const FILE_NAME = 'global-classes';
+
+	public function register_hooks() {
+		add_action( 'elementor/import-export/export-kit', function ( Export $export ) {
+			$export->register( new Export_Runner() );
+		} );
+
+		add_action( 'elementor/import-export/import-kit', function ( Import $import ) {
+			$import->register( new Import_Runner() );
+		} );
+	}
+}

wp-content/plugins/elementor/modules/global-classes/import-export/import-runner.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\ImportExport;
+
+use Elementor\App\Modules\ImportExport\Runners\Import\Import_Runner_Base;
+use Elementor\App\Modules\ImportExport\Utils as ImportExportUtils;
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+use Elementor\Modules\GlobalClasses\Global_Classes_Parser;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Import_Runner extends Import_Runner_Base {
+	public static function get_name(): string {
+		return 'global-classes';
+	}
+
+	public function should_import( array $data ) {
+		// Same as the site-settings runner.
+		return (
+			isset( $data['include'] ) &&
+			in_array( 'settings', $data['include'], true ) &&
+			! empty( $data['site_settings']['settings'] ) &&
+			! empty( $data['extracted_directory_path'] )
+		);
+	}
+
+	public function import( array $data, array $imported_data ) {
+		$kit = Plugin::$instance->kits_manager->get_active_kit();
+
+		$file_name = Import_Export::FILE_NAME;
+		$global_classes = ImportExportUtils::read_json_file( "{$data['extracted_directory_path']}/{$file_name}.json" );
+
+		if ( ! $kit || ! $global_classes ) {
+			return [];
+		}
+
+		$global_classes_result = Global_Classes_Parser::make()->parse( $global_classes );
+
+		if ( ! $global_classes_result->is_valid() ) {
+			return [];
+		}
+
+		$global_classes = $global_classes_result->unwrap();
+
+		Global_Classes_Repository::make()->put(
+			$global_classes['items'],
+			$global_classes['order']
+		);
+
+		return $global_classes;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/module.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses;
+
+use Elementor\Core\Base\Module as BaseModule;
+use Elementor\Core\Experiments\Manager as Experiments_Manager;
+use Elementor\Modules\AtomicWidgets\Module as Atomic_Widgets_Module;
+use Elementor\Modules\GlobalClasses\Database\Global_Classes_Database_Updater;
+use Elementor\Modules\GlobalClasses\ImportExport\Import_Export;
+use Elementor\Modules\GlobalClasses\ImportExportCustomization\Import_Export_Customization;
+use Elementor\Modules\GlobalClasses\Usage\Global_Classes_Usage;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+class Module extends BaseModule {
+	const NAME = 'e_classes';
+	const ENFORCE_CAPABILITIES_EXPERIMENT = 'global_classes_should_enforce_capabilities';
+
+	// TODO: Add global classes package
+	const PACKAGES = [
+		'editor-global-classes',
+	];
+
+	public function get_name() {
+		return 'global-classes';
+	}
+
+	public function __construct() {
+		parent::__construct();
+
+		$this->register_features();
+
+		$is_feature_active = Plugin::$instance->experiments->is_feature_active( self::NAME );
+		$is_atomic_widgets_active = Plugin::$instance->experiments->is_feature_active( Atomic_Widgets_Module::EXPERIMENT_NAME );
+
+		// TODO: When the `e_atomic_elements` feature is not hidden, add it as a dependency
+		if ( $is_feature_active && $is_atomic_widgets_active ) {
+			add_filter( 'elementor/editor/v2/packages', fn( $packages ) => $this->add_packages( $packages ) );
+
+			( new Global_Classes_Usage() )->register_hooks();
+			( new Global_Classes_REST_API() )->register_hooks();
+			( new Atomic_Global_Styles() )->register_hooks();
+			( new Global_Classes_Cleanup() )->register_hooks();
+			( new Import_Export() )->register_hooks();
+			( new Import_Export_Customization() )->register_hooks();
+			( new Global_Classes_Database_Updater() )->register();
+		}
+	}
+
+	private function register_features() {
+		Plugin::$instance->experiments->add_feature([
+			'name' => self::NAME,
+			'title' => esc_html__( 'Global Classes', 'elementor' ),
+			'description' => esc_html__( 'Enable global CSS classes.', 'elementor' ),
+			'hidden' => true,
+			'default' => Experiments_Manager::STATE_INACTIVE,
+			'release_status' => Experiments_Manager::RELEASE_STATUS_ALPHA,
+		]);
+
+		Plugin::$instance->experiments->add_feature([
+			'name' => self::ENFORCE_CAPABILITIES_EXPERIMENT,
+			'title' => esc_html__( 'Enforce global classes capabilities', 'elementor' ),
+			'description' => esc_html__( 'Enforce global classes capabilities.', 'elementor' ),
+			'hidden' => true,
+			'default' => Experiments_Manager::STATE_ACTIVE,
+			'release_status' => Experiments_Manager::RELEASE_STATUS_DEV,
+		]);
+	}
+
+	private function add_packages( $packages ) {
+		return array_merge( $packages, self::PACKAGES );
+	}
+}

wp-content/plugins/elementor/modules/global-classes/usage/applied-global-classes-usage.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Usage;
+
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+use Elementor\Plugin;
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly.
+}
+
+/**
+ * Collects and exposes usage data for all global CSS classes across Elementor documents.
+ */
+class Applied_Global_Classes_Usage {
+
+	/**
+	 * Document types that should be excluded from usage reporting.
+	 *
+	 * @var string[]
+	 */
+	private array $excluded_types = [ 'e-flexbox', 'template' ];
+
+	/**
+	 * Tracks usage for each global class.
+	 *
+	 * @var array<string, Css_Class_Usage>
+	 */
+	private array $class_usages = [];
+
+	/**
+	 * Returns the total usage count per class ID (excluding template-only classes).
+	 *
+	 * @return array<string, int>
+	 */
+	public function get(): array {
+		$this->build_class_usages();
+
+		$result = [];
+		foreach ( $this->class_usages as $class_id => $usage ) {
+			if ( $usage->get_total_usage() > 0 ) {
+				$result[ $class_id ] = $usage->get_total_usage();
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Returns detailed usage information per class ID.
+	 * Each class ID maps to a list of document usages (excluding excluded types).
+	 *
+	 * @return array<string, array{
+	 *     pageId: int,
+	 *     title: string,
+	 *     type: string,
+	 *     total: int,
+	 *     elements: string[]
+	 * }>
+	 */
+	public function get_detailed_usage(): array {
+		$this->build_class_usages();
+
+		$result = [];
+
+		foreach ( $this->class_usages as $class_id => $usage ) {
+			$pages = $usage->get_pages();
+
+			$filtered_pages = array_filter(
+				$pages,
+				fn( $page_data ) => ! in_array( $page_data['type'], $this->excluded_types, true )
+			);
+
+			if ( empty( $filtered_pages ) ) {
+				continue;
+			}
+
+			foreach ( $filtered_pages as $page_id => $page_data ) {
+				$result[ $class_id ][] = [
+					'pageId'   => $page_id,
+					'title'    => $page_data['title'],
+					'type'     => $page_data['type'],
+					'total'    => $page_data['total'],
+					'elements' => $page_data['elements'],
+				];
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Builds the internal usage map from all Elementor documents.
+	 *
+	 * This method initializes and aggregates class usage from all relevant documents,
+	 * merging duplicate class IDs found in multiple pages.
+	 */
+	private function build_class_usages(): void {
+		$this->class_usages = [];
+
+		$class_ids = Global_Classes_Repository::make()
+												->all()
+												->get_items()
+												->keys()
+												->all();
+
+		Plugin::$instance->db->iterate_elementor_documents(
+			function ( $document ) use ( $class_ids ) {
+				$usage = new Document_Usage( $document );
+				$usage->analyze();
+
+				foreach ( $usage->get_usages() as $class_id => $class_usage ) {
+					if ( ! in_array( $class_id, $class_ids, true ) ) {
+						continue;
+					}
+
+					if ( ! isset( $this->class_usages[ $class_id ] ) ) {
+						$this->class_usages[ $class_id ] = $class_usage;
+					} else {
+						$this->class_usages[ $class_id ]->merge( $class_usage );
+					}
+				}
+			}
+		);
+	}
+}

wp-content/plugins/elementor/modules/global-classes/usage/css-class-usage.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Usage;
+
+/**
+ * Tracks usage of a specific global CSS class across multiple Elementor documents.
+ */
+class Css_Class_Usage {
+
+	/** @var string */
+	private string $class_id;
+
+	/** @var int */
+	private int $total = 0;
+
+	/**
+	 * @var array<int, array{
+	 *     title: string,
+	 *     total: int,
+	 *     elements: string[],
+	 *     type?: string
+	 * }>
+	 */
+	private array $pages = [];
+
+	/**
+	 * Constructor.
+	 *
+	 * @param string $class_id Global CSS class ID.
+	 */
+	public function __construct( string $class_id ) {
+		$this->class_id = $class_id;
+	}
+
+	/**
+	 * Track usage of this class on a specific document and element.
+	 *
+	 * @param int         $page_id        Document ID.
+	 * @param string      $page_title     Document title.
+	 * @param string      $element_id     Element ID using this class.
+	 * @param string|null $document_type  Optional document type (e.g. header, footer, etc).
+	 */
+	public function track_usage( int $page_id, string $page_title, string $element_id, ?string $document_type = null ): void {
+		++$this->total;
+
+		if ( ! isset( $this->pages[ $page_id ] ) ) {
+			$this->pages[ $page_id ] = [
+				'title'    => $page_title,
+				'total'    => 0,
+				'elements' => [],
+			];
+
+			if ( $document_type ) {
+				$this->pages[ $page_id ]['type'] = $document_type;
+			}
+		}
+
+		++$this->pages[ $page_id ]['total'];
+		$this->pages[ $page_id ]['elements'][] = $element_id;
+	}
+
+	/**
+	 * Merge usage data from another instance with the same class ID.
+	 *
+	 * @param Css_Class_Usage $other The other usage object to merge in.
+	 *
+	 * @throws \InvalidArgumentException If the class IDs do not match.
+	 */
+	public function merge( Css_Class_Usage $other ): void {
+		if ( $other->get_class_id() !== $this->class_id ) {
+			throw new \InvalidArgumentException( 'Mismatched class ID' );
+		}
+
+		$this->total += $other->get_total_usage();
+
+		foreach ( $other->get_pages() as $page_id => $data ) {
+			if ( ! isset( $this->pages[ $page_id ] ) ) {
+				$this->pages[ $page_id ] = $data;
+			} else {
+				$this->pages[ $page_id ]['total'] += $data['total'];
+				$this->pages[ $page_id ]['elements'] = array_merge(
+					$this->pages[ $page_id ]['elements'],
+					$data['elements']
+				);
+
+				if ( empty( $this->pages[ $page_id ]['type'] ) && ! empty( $data['type'] ) ) {
+					$this->pages[ $page_id ]['type'] = $data['type'];
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get the global class ID this instance tracks.
+	 *
+	 * @return string
+	 */
+	public function get_class_id(): string {
+		return $this->class_id;
+	}
+
+	/**
+	 * Get the total number of elements using this class.
+	 *
+	 * @return int
+	 */
+	public function get_total_usage(): int {
+		return $this->total;
+	}
+
+	/**
+	 * Get a map of document usages.
+	 *
+	 * @return array<int, array{title: string, total: int, elements: string[], type?: string}>
+	 */
+	public function get_pages(): array {
+		return $this->pages;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/usage/document-usage.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Usage;
+
+use Elementor\Plugin;
+use Elementor\Core\Base\Document as ElementorDocument;
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+
+/**
+ * Tracks usage of global CSS classes within a specific Elementor document.
+ */
+class Document_Usage {
+
+
+	/** @var ElementorDocument */
+	private ElementorDocument $document;
+
+	/** @var array<string, Css_Class_Usage> */
+	private array $usages = [];
+
+	/**
+	 * Constructor.
+	 *
+	 * @param ElementorDocument $document The Elementor document object.
+	 */
+	public function __construct( ElementorDocument $document ) {
+		$this->document = $document;
+	}
+
+	/**
+	 * Analyze the document to find and record usage of global CSS classes.
+	 */
+	public function analyze(): void {
+		$page_id       = $this->document->get_main_id();
+		$page_title    = $this->document->get_post()->post_title;
+		$class_ids     = $this->get_all_global_class_ids();
+		$elements_data = $this->document->get_elements_raw_data() ?? [];
+
+		$document_type = $this->document->get_type();
+		if ( empty( $document_type ) ) {
+			$document_type = get_post_type( $page_id ) ?? 'unknown';
+		}
+
+		if ( empty( $elements_data ) ) {
+			return;
+		}
+
+		Plugin::$instance->db->iterate_data(
+			$elements_data,
+			function ( $element_data ) use ( $class_ids, $page_id, $page_title, $document_type ) {
+				$class_values = $element_data['settings']['classes']['value'] ?? [];
+
+				if ( empty( $class_values ) || ! is_array( $class_values ) ) {
+					return;
+				}
+
+				foreach ( $class_values as $class_id ) {
+					if ( ! in_array( $class_id, $class_ids, true ) ) {
+						continue;
+					}
+
+					if ( ! isset( $this->usages[ $class_id ] ) ) {
+						$this->usages[ $class_id ] = new Css_Class_Usage( $class_id );
+					}
+
+					$this->usages[ $class_id ]->track_usage(
+						$page_id,
+						$page_title,
+						$element_data['id'] ?? 'unknown',
+						$document_type
+					);
+				}
+			}
+		);
+	}
+
+	/**
+	 * Get all recorded usages of global CSS classes in this document.
+	 *
+	 * @return array<string, Css_Class_Usage>
+	 */
+	public function get_usages(): array {
+		return $this->usages;
+	}
+
+	/**֜
+	 * Retrieve all registered global CSS class IDs.
+	 *
+	 * @return string[]
+	 */
+	protected function get_all_global_class_ids(): array {
+		return Global_Classes_Repository::make()
+			->all()
+			->get_items()
+			->filter( fn( $item ) => ! empty( $item['id'] ?? null ) )
+			->keys()
+			->all();
+	}
+}

wp-content/plugins/elementor/modules/global-classes/usage/global-classes-usage.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Usage;
+
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\GlobalClasses\Usage\Applied_Global_Classes_Usage;
+use Elementor\Modules\GlobalClasses\Global_Classes_Repository;
+
+class Global_Classes_Usage {
+	const MIN_CLASSES_COUNT = 1;
+	public function register_hooks() {
+		add_filter( 'elementor/tracker/send_tracking_data_params', fn( $params ) => $this->add_tracking_data( $params ) );
+	}
+
+	private function add_tracking_data( $params ) {
+		$params['usages']['global_classes']['total_count'] = Global_Classes_Repository::make()->all()->get_items()->count();
+
+		if ( 0 === $params['usages']['global_classes']['total_count'] ) {
+			return $params;
+		}
+
+		$applied_global_classes_usage = ( new Applied_Global_Classes_Usage() )->get();
+
+		$applied_global_classes_usage = Collection::make( $applied_global_classes_usage )
+			->filter( fn( $count ) => $count <= self::MIN_CLASSES_COUNT )
+			->keys()
+			->count();
+
+		if ( ! empty( $applied_global_classes_usage ) ) {
+			$params['usages']['global_classes']['low_usage_global_classes_count'] = $applied_global_classes_usage;
+		}
+
+		return $params;
+	}
+}

wp-content/plugins/elementor/modules/global-classes/utils/atomic-elements-utils.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Elementor\Modules\GlobalClasses\Utils;
+
+use Elementor\Core\Base\Document;
+use Elementor\Core\Utils\Collection;
+use Elementor\Modules\AtomicWidgets\Elements\Base\Atomic_Element_Base;
+use Elementor\Modules\AtomicWidgets\Elements\Base\Atomic_Widget_Base;
+use Elementor\Plugin;
+
+class Atomic_Elements_Utils {
+
+	public static function is_classes_prop( $prop ) {
+		// phpcs:ignore
+		return 'plain' === $prop::$KIND && 'classes' === $prop->get_key();
+	}
+
+	public static function get_element_type( $element ) {
+		return 'widget' === $element['elType'] ? $element['widgetType'] : $element['elType'];
+	}
+
+	public static function get_element_instance( $element_type ) {
+		$widget = Plugin::$instance->widgets_manager->get_widget_types( $element_type );
+		$element = Plugin::$instance->elements_manager->get_element_types( $element_type );
+
+		return $widget ?? $element;
+	}
+
+	public static function is_atomic_element( $element_instance ) {
+		if ( ! $element_instance ) {
+			return false;
+		}
+
+		return (
+			$element_instance instanceof Atomic_Element_Base ||
+			$element_instance instanceof Atomic_Widget_Base
+		);
+	}
+}