@elementor/editor-audits 4.3.0-1036

package/src/audits/cookie-policy.ts

@@ -0,0 +1,32 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit } from '../types';
+
+export const audit: Audit = {
+	id: 'audits/cookie-policy',
+	title: __( 'Cookie policy', 'elementor' ),
+	description: __(
+		'A cookie policy is required by privacy regulations such as GDPR (EU) or CCPA (US) to inform visitors about tracking and data collection.',
+		'elementor'
+	),
+	fixHint: __( 'Install the Cookiez plugin to add a cookie policy to your website.', 'elementor' ),
+	categories: [ 'compliance' ],
+	severity: 'info',
+	weight: 1,
+	evaluate: ( ctx ) => {
+		if ( ctx.pageContext.cookiez_plugin_active ) {
+			return { status: 'pass' };
+		}
+
+		return {
+			status: 'fail',
+			violations: [
+				{
+					auditId: audit.id,
+					label: __( 'Cookiez plugin is not installed or active.', 'elementor' ),
+					externalUrl: ctx.pageContext.cookiez_plugin_url,
+				},
+			],
+		};
+	},
+};

package/src/audits/deep-nesting.ts

@@ -0,0 +1,45 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { walkElements } from '../utils/walk';
+
+const MAX_NESTING_DEPTH = 6;
+
+export const audit: Audit = {
+	id: 'audits/deep-nesting',
+	title: __( 'Deep container nesting', 'elementor' ),
+	description: __(
+		'Container nesting exceeds the recommended depth. Deep DOM trees hurt rendering performance and readability.',
+		'elementor'
+	),
+	fixHint: __( 'Flatten the layout by removing unnecessary wrapper containers.', 'elementor' ),
+	categories: [ 'performance', 'best-practices' ],
+	severity: 'warning',
+	weight: 5,
+	evaluate: ( ctx ) => {
+		if ( ctx.elements.tree.length === 0 ) {
+			return { status: 'skipped', reason: __( 'No elements', 'elementor' ) };
+		}
+
+		const violations: AuditViolation[] = [];
+
+		walkElements( ctx.elements.tree, ( node, parents ) => {
+			if ( node.elType !== 'container' ) {
+				return;
+			}
+
+			const depth = parents.length + 1;
+
+			if ( depth > MAX_NESTING_DEPTH ) {
+				violations.push( {
+					auditId: audit.id,
+					elementId: node.id,
+					targetHint: 'element-settings',
+					label: __( 'Container nesting is too deep.', 'elementor' ),
+				} );
+			}
+		} );
+
+		return violations.length === 0 ? { status: 'pass' } : { status: 'fail', violations };
+	},
+};

package/src/audits/default-design-system.ts

@@ -0,0 +1,32 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit } from '../types';
+
+export const audit: Audit = {
+	id: 'audits/default-design-system',
+	title: __( 'Default website kit', 'elementor' ),
+	description: __(
+		'Your website is using the default design system colors and fonts. Custom branding makes the website feel uniquely yours.',
+		'elementor'
+	),
+	fixHint: __( 'Open Site Settings and customize your kit (colors, fonts, layout).', 'elementor' ),
+	categories: [ 'best-practices' ],
+	severity: 'info',
+	weight: 1,
+	evaluate: ( ctx ) => {
+		if ( ! ctx.pageContext.kit_is_default_unchanged ) {
+			return { status: 'pass' };
+		}
+
+		return {
+			status: 'fail',
+			violations: [
+				{
+					auditId: audit.id,
+					label: __( 'Kit appears unchanged from default.', 'elementor' ),
+					targetHint: 'site-settings',
+				},
+			],
+		};
+	},
+};

package/src/audits/deprecated-widgets.ts

@@ -0,0 +1,57 @@
+import { getWidgetsCache } from '@elementor/editor-elements';
+import { __ } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { walkElements } from '../utils/walk';
+
+const DEPRECATION_CONTROL_NAME = 'deprecation_message';
+
+export const audit: Audit = {
+	id: 'audits/deprecated-widgets',
+	title: __( 'Deprecated widgets', 'elementor' ),
+	description: __(
+		'Deprecated widgets should not be used. For better capabilities use the recommended replacement.',
+		'elementor'
+	),
+	fixHint: __( 'Replace each deprecated widget with the recommended new widget shown in its panel.', 'elementor' ),
+	categories: [ 'best-practices', 'performance' ],
+	severity: 'warning',
+	weight: 7,
+	evaluate: ( ctx ) => {
+		const widgetsCache = getWidgetsCache();
+
+		if ( ! widgetsCache ) {
+			return { status: 'skipped', reason: 'widgets-cache-unavailable' };
+		}
+
+		const violations: AuditViolation[] = [];
+
+		walkElements( ctx.elements.tree, ( node ) => {
+			if ( node.elType !== 'widget' ) {
+				return;
+			}
+
+			const config = widgetsCache[ node.widgetType ?? '' ];
+
+			if ( ! config?.controls ) {
+				return;
+			}
+
+			const controls = config.controls as Record< string, unknown >;
+			const deprecationControl = controls[ DEPRECATION_CONTROL_NAME ];
+
+			if ( ! deprecationControl || typeof deprecationControl !== 'object' ) {
+				return;
+			}
+
+			violations.push( {
+				auditId: audit.id,
+				elementId: node.id,
+				targetHint: 'element-settings',
+				label: __( 'Using deprecated widget.', 'elementor' ),
+			} );
+		} );
+
+		return violations.length === 0 ? { status: 'pass' } : { status: 'fail', violations };
+	},
+};

package/src/audits/heading-structure.ts

@@ -0,0 +1,294 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { walkElements } from '../utils/walk';
+
+type HeadingControlDescriptor = {
+	control: string;
+	when?: Record< string, string | string[] >;
+	requiresNonEmpty?: string;
+	requiresAnyNonEmpty?: string[];
+	repeat?: {
+		items: string;
+		textField?: string;
+		itemWhen?: Record< string, string | string[] >;
+		tagSource?: 'widget' | 'item';
+	};
+};
+
+type HeadingControlsRegistry = Record< string, HeadingControlDescriptor[] >;
+
+type PageHeading = {
+	elementId: string;
+	level: number;
+};
+
+type Settings = Record< string, unknown >;
+
+const HEADING_LEVELS = [ 'h1', 'h2', 'h3', 'h4', 'h5', 'h6' ] as const;
+
+const HEADING_CONTROLS_REGISTRY: HeadingControlsRegistry = {
+	// Core
+	heading: [ { control: 'header_size', requiresNonEmpty: 'title' } ],
+	'e-heading': [ { control: 'tag', requiresNonEmpty: 'title' } ],
+	'icon-box': [ { control: 'title_size', requiresNonEmpty: 'title_text' } ],
+	'image-box': [ { control: 'title_size', requiresNonEmpty: 'title_text' } ],
+	counter: [ { control: 'title_tag', requiresNonEmpty: 'title' } ],
+	progress: [ { control: 'title_tag', when: { title_display: 'yes' }, requiresNonEmpty: 'title' } ],
+	accordion: [ { control: 'title_html_tag', repeat: { items: 'tabs', textField: 'tab_title' } } ],
+	toggle: [ { control: 'title_html_tag', repeat: { items: 'tabs', textField: 'tab_title' } } ],
+	divider: [ { control: 'html_tag', when: { look: 'line_text' }, requiresNonEmpty: 'text' } ],
+	'nested-accordion': [ { control: 'title_tag', repeat: { items: 'items', textField: 'item_title' } } ],
+	'link-in-bio': [
+		{ control: 'bio_heading_tag', requiresNonEmpty: 'bio_heading' },
+		{ control: 'bio_title_tag', requiresNonEmpty: 'bio_title' },
+		{ control: 'bio_about_tag', requiresNonEmpty: 'bio_about' },
+	],
+	// Pro — static / repeater
+	'animated-headline': [
+		{
+			control: 'tag',
+			requiresAnyNonEmpty: [ 'before_text', 'highlighted_text', 'rotating_text', 'after_text' ],
+		},
+	],
+	'author-box': [ { control: 'author_name_tag', requiresNonEmpty: 'author_name' } ],
+	'call-to-action': [
+		{ control: 'title_tag', requiresNonEmpty: 'title' },
+		{ control: 'description_tag', requiresNonEmpty: 'description' },
+	],
+	'flip-box': [
+		{ control: 'title_tag', requiresNonEmpty: 'title_text_a' },
+		{ control: 'description_tag', requiresNonEmpty: 'description_text_a' },
+		{ control: 'title_tag', requiresNonEmpty: 'title_text_b' },
+		{ control: 'description_tag', requiresNonEmpty: 'description_text_b' },
+	],
+	'price-list': [
+		{ control: 'title_tag', repeat: { items: 'price_list', textField: 'title' } },
+		{ control: 'description_tag', repeat: { items: 'price_list', textField: 'item_description' } },
+	],
+	'price-table': [ { control: 'heading_tag', requiresNonEmpty: 'heading' } ],
+	slides: [
+		{ control: 'slides_title_tag', repeat: { items: 'slides', textField: 'heading' } },
+		{ control: 'slides_description_tag', repeat: { items: 'slides', textField: 'description' } },
+	],
+	'table-of-contents': [ { control: 'html_tag', requiresNonEmpty: 'title' } ],
+	'video-playlist': [
+		{ control: 'playlist_title_tag', requiresNonEmpty: 'playlist_title' },
+		{
+			control: 'section_html_tag',
+			repeat: { items: 'tabs', tagSource: 'item', itemWhen: { type: 'section' }, textField: 'title' },
+		},
+		{
+			control: 'video_html_tag',
+			repeat: {
+				items: 'tabs',
+				tagSource: 'item',
+				itemWhen: { type: [ 'youtube', 'vimeo', 'hosted' ] },
+				textField: 'title',
+			},
+		},
+	],
+	sitemap: [ { control: 'sitemap_title_tag', repeat: { items: 'sitemap_items', textField: 'sitemap_title' } } ],
+	'loop-grid': [
+		{
+			control: 'nothing_found_message_html_tag',
+			when: { enable_nothing_found_message: 'yes' },
+			requiresNonEmpty: 'nothing_found_message_text',
+		},
+	],
+	search: [
+		{
+			control: 'nothing_found_message_html_tag',
+			when: { enable_nothing_found_message: 'yes' },
+			requiresNonEmpty: 'nothing_found_message_text',
+		},
+	],
+	// Pro — theme / Woo
+	posts: [ { control: 'title_tag', when: { show_title: 'yes' } } ],
+	'archive-posts': [ { control: 'title_tag', when: { show_title: 'yes' } } ],
+	portfolio: [ { control: 'title_tag', when: { show_title: 'yes' } } ],
+	'theme-post-title': [ { control: 'header_size' } ],
+	'theme-page-title': [ { control: 'header_size' } ],
+	'theme-archive-title': [ { control: 'header_size' } ],
+	'theme-site-title': [ { control: 'header_size' } ],
+	'woocommerce-product-title': [ { control: 'header_size' } ],
+};
+
+function isNonEmptyString( value: unknown ): boolean {
+	return typeof value === 'string' && value.trim() !== '';
+}
+
+function matchesWhen( settings: Settings, when?: Record< string, string | string[] > ): boolean {
+	if ( ! when ) {
+		return true;
+	}
+
+	return Object.entries( when ).every( ( [ key, expected ] ) => {
+		const actual = settings[ key ];
+
+		if ( Array.isArray( expected ) ) {
+			return expected.includes( String( actual ) );
+		}
+
+		return String( actual ) === expected;
+	} );
+}
+
+function hasRequiredText( settings: Settings, key?: string ): boolean {
+	if ( ! key ) {
+		return true;
+	}
+
+	return isNonEmptyString( settings[ key ] );
+}
+
+function hasAnyRequiredText( settings: Settings, keys?: string[] ): boolean {
+	if ( ! keys?.length ) {
+		return true;
+	}
+
+	return keys.some( ( key ) => isNonEmptyString( settings[ key ] ) );
+}
+
+function parseHeadingLevel( raw: unknown ): number | null {
+	if ( typeof raw !== 'string' ) {
+		return null;
+	}
+
+	const idx = HEADING_LEVELS.indexOf( raw.toLowerCase() as ( typeof HEADING_LEVELS )[ number ] );
+
+	return idx >= 0 ? idx + 1 : null;
+}
+
+function getRepeaterRows( settings: Settings, key: string ): Settings[] {
+	const rows = settings[ key ];
+
+	return Array.isArray( rows ) ? ( rows as Settings[] ) : [];
+}
+
+function pushHeading( headings: PageHeading[], elementId: string, raw: unknown ): void {
+	const level = parseHeadingLevel( raw );
+
+	if ( level !== null ) {
+		headings.push( { elementId, level } );
+	}
+}
+
+function extractHeadingsFromWidget( elementId: string, widgetType: string, settings: Settings ): PageHeading[] {
+	const descriptors = HEADING_CONTROLS_REGISTRY[ widgetType ];
+
+	if ( ! descriptors ) {
+		return [];
+	}
+
+	const headings: PageHeading[] = [];
+
+	for ( const descriptor of descriptors ) {
+		if ( ! matchesWhen( settings, descriptor.when ) ) {
+			continue;
+		}
+
+		if ( ! hasRequiredText( settings, descriptor.requiresNonEmpty ) ) {
+			continue;
+		}
+
+		if ( ! hasAnyRequiredText( settings, descriptor.requiresAnyNonEmpty ) ) {
+			continue;
+		}
+
+		if ( descriptor.repeat ) {
+			const { items, textField, itemWhen, tagSource = 'widget' } = descriptor.repeat;
+
+			for ( const row of getRepeaterRows( settings, items ) ) {
+				if ( ! matchesWhen( row, itemWhen ) ) {
+					continue;
+				}
+
+				if ( textField && ! hasRequiredText( row, textField ) ) {
+					continue;
+				}
+
+				const raw = tagSource === 'item' ? row[ descriptor.control ] : settings[ descriptor.control ];
+
+				pushHeading( headings, elementId, raw );
+			}
+		} else {
+			pushHeading( headings, elementId, settings[ descriptor.control ] );
+		}
+	}
+
+	return headings;
+}
+
+function extractPageHeadings( tree: Parameters< typeof walkElements >[ 0 ] ): PageHeading[] {
+	const headings: PageHeading[] = [];
+
+	walkElements( tree, ( node ) => {
+		if ( node.elType !== 'widget' || ! node.widgetType ) {
+			return;
+		}
+
+		headings.push( ...extractHeadingsFromWidget( node.id, node.widgetType, node.settings ) );
+	} );
+
+	return headings;
+}
+
+export const audit: Audit = {
+	id: 'audits/heading-structure',
+	title: __( 'Heading structure', 'elementor' ),
+	description: __( 'Pages should have exactly one H1 and a non-skipping heading order.', 'elementor' ),
+	fixHint: __( 'Ensure your page has one H1 and that heading levels do not skip (no H2 → H4).', 'elementor' ),
+	categories: [ 'seo', 'accessibility' ],
+	severity: 'error',
+	weight: 10,
+	evaluate: ( ctx ) => {
+		if ( ctx.elements.tree.length === 0 ) {
+			return { status: 'skipped', reason: __( 'No elements', 'elementor' ) };
+		}
+
+		const headings = extractPageHeadings( ctx.elements.tree );
+
+		const violations: AuditViolation[] = [];
+
+		if ( headings.length === 0 ) {
+			violations.push( {
+				auditId: audit.id,
+				label: __( 'No headings found on the page.', 'elementor' ),
+			} );
+		} else {
+			const h1Count = headings.filter( ( h ) => h.level === 1 ).length;
+
+			if ( h1Count === 0 ) {
+				violations.push( { auditId: audit.id, label: __( 'No H1 on the page.', 'elementor' ) } );
+			}
+
+			if ( h1Count > 1 ) {
+				headings
+					.filter( ( h ) => h.level === 1 )
+					.slice( 1 )
+					.forEach( ( h ) =>
+						violations.push( {
+							auditId: audit.id,
+							elementId: h.elementId,
+							targetHint: 'element-settings',
+							label: __( 'More than one H1 on the page.', 'elementor' ),
+						} )
+					);
+			}
+
+			for ( let i = 1; i < headings.length; i++ ) {
+				if ( headings[ i ].level - headings[ i - 1 ].level > 1 ) {
+					violations.push( {
+						auditId: audit.id,
+						elementId: headings[ i ].elementId,
+						targetHint: 'element-settings',
+						label: __( 'Heading level skipped.', 'elementor' ),
+					} );
+				}
+			}
+		}
+
+		return violations.length === 0 ? { status: 'pass' } : { status: 'fail', violations };
+	},
+};

package/src/audits/hidden-elements.ts

@@ -0,0 +1,41 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { walkElements } from '../utils/walk';
+
+function isHiddenOnAllDevices( settings: Record< string, unknown > ): boolean {
+	return Boolean( settings.hide_desktop ) && Boolean( settings.hide_tablet ) && Boolean( settings.hide_mobile );
+}
+
+export const audit: Audit = {
+	id: 'audits/hidden-elements',
+	title: __( 'Hidden elements', 'elementor' ),
+	description: __(
+		'Elements hidden on all devices simultaneously are effectively dead code in the page tree.',
+		'elementor'
+	),
+	fixHint: __( 'Remove the element or make it visible on at least one device breakpoint.', 'elementor' ),
+	categories: [ 'best-practices', 'performance' ],
+	severity: 'info',
+	weight: 3,
+	evaluate: ( ctx ) => {
+		if ( ctx.elements.tree.length === 0 ) {
+			return { status: 'skipped', reason: __( 'No elements', 'elementor' ) };
+		}
+
+		const violations: AuditViolation[] = [];
+
+		walkElements( ctx.elements.tree, ( node ) => {
+			if ( isHiddenOnAllDevices( node.settings ) ) {
+				violations.push( {
+					auditId: audit.id,
+					elementId: node.id,
+					targetHint: 'element-settings',
+					label: __( 'Element is hidden on all devices.', 'elementor' ),
+				} );
+			}
+		} );
+
+		return violations.length === 0 ? { status: 'pass' } : { status: 'fail', violations };
+	},
+};

package/src/audits/images-alt-text.ts

@@ -0,0 +1,47 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { hasMeaningfulAlt, isImageSourcePresent } from '../utils/image-alt';
+import { hasPageImages, walkImageLikeSources } from '../utils/image-like-sources';
+
+export const audit: Audit = {
+	id: 'audits/images-alt-text',
+	title: __( 'Images alt text', 'elementor' ),
+	description: __( 'Every image needs a meaningful alt attribute for screen readers and image-search.', 'elementor' ),
+	fixHint: __( "Open the image's settings and add an Alt Text describing the image.", 'elementor' ),
+	categories: [ 'seo', 'accessibility' ],
+	severity: 'error',
+	weight: 10,
+	evaluate: ( ctx ) => {
+		if ( ! hasPageImages( ctx.elements.tree ) ) {
+			return { status: 'skipped', reason: __( 'No images', 'elementor' ) };
+		}
+
+		const violations: AuditViolation[] = [];
+		const failedWidgetIds = new Set< string >();
+		let missingAltImageCount = 0;
+
+		walkImageLikeSources( ctx.elements.tree, ( { node, media } ) => {
+			if ( ! isImageSourcePresent( media ) || hasMeaningfulAlt( media, ctx.pageContext ) ) {
+				return;
+			}
+
+			missingAltImageCount++;
+
+			if ( ! failedWidgetIds.has( node.id ) ) {
+				failedWidgetIds.add( node.id );
+				violations.push( {
+					auditId: audit.id,
+					elementId: node.id,
+					targetHint: 'element-settings',
+					label: __( 'Image is missing alt text.', 'elementor' ),
+					externalUrl: ctx.pageContext.ally_plugin_url,
+				} );
+			}
+		} );
+
+		return violations.length === 0
+			? { status: 'pass' }
+			: { status: 'fail', violations, metadata: { missingAltImageCount } };
+	},
+};

package/src/audits/images-too-large.ts

@@ -0,0 +1,61 @@
+import { __, sprintf } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { hasPageImages, walkImageLikeSources } from '../utils/image-like-sources';
+
+const SIZE_THRESHOLD_BYTES = 500 * 1024;
+const BYTES_PER_KB = 1024;
+
+export const audit: Audit = {
+	id: 'audits/images-too-large',
+	title: __( 'Oversized images', 'elementor' ),
+	description: __( 'Large image files slow down the page.', 'elementor' ),
+	fixHint: __( 'Replace the image with a smaller version or enable image optimization.', 'elementor' ),
+	categories: [ 'performance' ],
+	severity: 'warning',
+	weight: 7,
+	evaluate: ( ctx ) => {
+		if ( ! hasPageImages( ctx.elements.tree ) ) {
+			return { status: 'skipped', reason: __( 'No images', 'elementor' ) };
+		}
+
+		const widgetMaxKb = new Map< string, number >();
+		let oversizedImageCount = 0;
+
+		walkImageLikeSources( ctx.elements.tree, ( { node, media } ) => {
+			const id = media.id;
+
+			if ( ! id ) {
+				return;
+			}
+
+			const size = ctx.pageContext.image_sizes[ id ];
+
+			if ( ! size || size.filesize_bytes <= SIZE_THRESHOLD_BYTES ) {
+				return;
+			}
+
+			oversizedImageCount++;
+
+			const kb = Math.round( size.filesize_bytes / BYTES_PER_KB );
+			const currentMax = widgetMaxKb.get( node.id ) ?? 0;
+			widgetMaxKb.set( node.id, Math.max( currentMax, kb ) );
+		} );
+
+		const violations: AuditViolation[] = Array.from( widgetMaxKb.entries() ).map( ( [ elementId, kb ] ) => ( {
+			auditId: audit.id,
+			elementId,
+			targetHint: 'element-settings' as const,
+			label: sprintf(
+				/* translators: %d is the image file size in kilobytes. */
+				__( 'Image is %d KB (over 500 KB).', 'elementor' ),
+				kb
+			),
+			externalUrl: ctx.pageContext.image_optimization_plugin_url,
+		} ) );
+
+		return violations.length === 0
+			? { status: 'pass' }
+			: { status: 'fail', violations, metadata: { oversizedImageCount } };
+	},
+};

package/src/audits/nested-boxed-containers.ts

@@ -0,0 +1,44 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit, type AuditViolation } from '../types';
+import { walkElements } from '../utils/walk';
+
+function isBoxed( settings: Record< string, unknown > ): boolean {
+	return settings.content_width === 'boxed';
+}
+
+export const audit: Audit = {
+	id: 'audits/nested-boxed-containers',
+	title: __( 'Boxed container nested inside a boxed parent', 'elementor' ),
+	description: __( 'An inner container does not need to be boxed when its parent already is.', 'elementor' ),
+	fixHint: __( "Change the inner container's content width to Full Width.", 'elementor' ),
+	categories: [ 'best-practices', 'performance' ],
+	severity: 'info',
+	weight: 5,
+	evaluate: ( ctx ) => {
+		if ( ctx.elements.tree.length === 0 ) {
+			return { status: 'skipped', reason: __( 'No elements', 'elementor' ) };
+		}
+
+		const violations: AuditViolation[] = [];
+
+		walkElements( ctx.elements.tree, ( node, parents ) => {
+			if ( node.elType !== 'container' || ! isBoxed( node.settings ) ) {
+				return;
+			}
+
+			const nearestContainerAncestor = [ ...parents ].reverse().find( ( p ) => p.elType === 'container' );
+
+			if ( nearestContainerAncestor && isBoxed( nearestContainerAncestor.settings ) ) {
+				violations.push( {
+					auditId: audit.id,
+					elementId: node.id,
+					targetHint: 'element-settings',
+					label: __( 'Nested boxed container.', 'elementor' ),
+				} );
+			}
+		} );
+
+		return violations.length === 0 ? { status: 'pass' } : { status: 'fail', violations };
+	},
+};

package/src/audits/page-excerpt.ts

@@ -0,0 +1,30 @@
+import { __ } from '@wordpress/i18n';
+
+import { type Audit } from '../types';
+
+export const audit: Audit = {
+	id: 'audits/page-excerpt',
+	title: __( 'Page excerpt', 'elementor' ),
+	description: __( 'A descriptive excerpt helps search engines and previews summarize the page.', 'elementor' ),
+	fixHint: __( 'Open Page Settings and write a short excerpt.', 'elementor' ),
+	categories: [ 'seo' ],
+	severity: 'warning',
+	weight: 5,
+	evaluate: ( ctx ) => {
+		if ( ctx.pageContext.post_excerpt ) {
+			return { status: 'pass' };
+		}
+
+		return {
+			status: 'fail',
+			violations: [
+				{
+					auditId: audit.id,
+					label: __( 'Page has no excerpt.', 'elementor' ),
+					targetHint: 'page-settings',
+					angieFix: true,
+				},
+			],
+		};
+	},
+};