first commit

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/component.js

@@ -0,0 +1,35 @@
+import ComponentBase from 'elementor-api/modules/component-base';
+
+export default class Component extends ComponentBase {
+	getNamespace() {
+		return 'panel/history';
+	}
+
+	defaultTabs() {
+		return {
+			actions: { title: __( 'Actions', 'elementor' ) },
+			revisions: { title: __( 'Revisions', 'elementor' ) },
+		};
+	}
+
+	defaultShortcuts() {
+		return {
+			actions: {
+				keys: 'ctrl+shift+h',
+			},
+		};
+	}
+
+	renderTab( tab ) {
+		elementor.getPanelView().setPage( 'historyPage' ).showView( tab );
+	}
+
+	activate() {
+		// Activate the tab component itself.
+		$e.components.activate( this.getTabRoute( this.currentTab ) );
+	}
+
+	getTabsWrapperSelector() {
+		return '#elementor-panel-elements-navigation';
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/history/component.js

@@ -0,0 +1,27 @@
+import ComponentBase from 'elementor-api/modules/component-base';
+import * as commands from 'elementor-document/history/commands/';
+
+export default class Component extends ComponentBase {
+	getNamespace() {
+		return 'panel/history/actions';
+	}
+
+	defaultCommands() {
+		return this.importCommands( commands );
+	}
+
+	defaultShortcuts() {
+		return {
+			undo: {
+				keys: 'ctrl+z',
+				exclude: [ 'input' ],
+				scopes: [ 'panel', 'navigator' ],
+			},
+			redo: {
+				keys: 'ctrl+shift+z, ctrl+y',
+				exclude: [ 'input' ],
+				scopes: [ 'panel', 'navigator' ],
+			},
+		};
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/history/empty.js

@@ -0,0 +1,13 @@
+export default class extends Marionette.ItemView {
+	getTemplate() {
+		return '#tmpl-elementor-panel-history-no-items';
+	}
+
+	id() {
+		return 'elementor-panel-history-no-items';
+	}
+
+	onDestroy() {
+		this._parent.$el.removeClass( 'elementor-empty' );
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/history/item-model.js

@@ -0,0 +1,15 @@
+module.exports = Backbone.Model.extend( {
+	defaults: {
+		id: 0,
+		type: '',
+		status: 'not_applied',
+		title: '',
+		subTitle: '',
+		action: '',
+		history: {},
+	},
+
+	initialize: function() {
+		this.set( 'items', new Backbone.Collection() );
+	},
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/history/item-view.js

@@ -0,0 +1,15 @@
+export default class extends Marionette.ItemView {
+	getTemplate() {
+		return '#tmpl-elementor-panel-history-item';
+	}
+
+	className() {
+		return 'elementor-history-item elementor-history-item-' + this.model.get( 'status' );
+	}
+
+	triggers() {
+		return {
+			click: 'click',
+		};
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/history/manager.js

@@ -0,0 +1,259 @@
+import ItemModel from './item-model';
+
+/**
+ * TODO: consider refactor this class.
+ * TODO: should be `Document/History` component.
+ * TODO: should be attached to elementor.history.history + BC.
+ */
+export default class HistoryManager {
+	currentItemID = null;
+
+	items = new Backbone.Collection( [], { model: ItemModel } );
+
+	active = true;
+
+	translations = {
+		add: __( 'Added', 'elementor' ),
+		change: __( 'Edited', 'elementor' ),
+		disable: __( 'Disabled', 'elementor' ),
+		duplicate: __( 'Duplicate', 'elementor' ),
+		enable: __( 'Enabled', 'elementor' ),
+		move: __( 'Moved', 'elementor' ),
+		paste: __( 'Pasted', 'elementor' ),
+		paste_style: __( 'Style Pasted', 'elementor' ),
+		remove: __( 'Removed', 'elementor' ),
+		reset_style: __( 'Style Reset', 'elementor' ),
+		reset_settings: __( 'Settings Reset', 'elementor' ),
+	};
+
+	constructor( document ) {
+		this.document = document;
+
+		this.currentItem = new Backbone.Model( {
+			id: 0,
+		} );
+	}
+
+	getActionLabel( itemData ) {
+		// TODO: this function should be static.
+		if ( this.translations[ itemData.type ] ) {
+			return this.translations[ itemData.type ];
+		}
+
+		return itemData.type;
+	}
+
+	navigate( isRedo ) {
+		const currentItem = this.items.find( ( model ) => {
+				return 'not_applied' === model.get( 'status' );
+			} ),
+			currentItemIndex = this.items.indexOf( currentItem ),
+			requiredIndex = isRedo ? currentItemIndex - 1 : currentItemIndex + 1;
+
+		if ( ( ! isRedo && ! currentItem ) || requiredIndex < 0 || requiredIndex >= this.items.length ) {
+			return;
+		}
+
+		this.doItem( requiredIndex );
+	}
+
+	setActive( value ) {
+		this.active = value;
+	}
+
+	getActive( value ) {
+		return this.active;
+	}
+
+	getItems() {
+		return this.items;
+	}
+
+	startItem( itemData ) {
+		this.currentItemID = this.addItem( itemData );
+
+		return this.currentItemID;
+	}
+
+	endItem( id ) {
+		if ( this.currentItemID !== id ) {
+			return;
+		}
+
+		this.currentItemID = null;
+	}
+
+	deleteItem( id ) {
+		const item = this.items.findWhere( {
+			id: id,
+		} );
+
+		this.items.remove( item );
+
+		this.currentItemID = null;
+	}
+
+	isItemStarted() {
+		return null !== this.currentItemID;
+	}
+
+	getCurrentId() {
+		return this.currentItemID;
+	}
+
+	addItem( itemData ) {
+		if ( ! this.getActive() ) {
+			return;
+		}
+
+		if ( ! this.items.length ) {
+			this.items.add( {
+				status: 'not_applied',
+				title: __( 'Editing Started', 'elementor' ),
+				subTitle: '',
+				action: '',
+				editing_started: true,
+			} );
+		}
+
+		// Remove old applied items from top of list
+		while ( this.items.length && 'applied' === this.items.first().get( 'status' ) ) {
+			this.items.shift();
+		}
+
+		const id = this.currentItemID ? this.currentItemID : new Date().getTime();
+
+		let currentItem = this.items.findWhere( {
+			id: id,
+		} );
+
+		if ( ! currentItem ) {
+			currentItem = new ItemModel( {
+				id: id,
+				title: itemData.title,
+				subTitle: itemData.subTitle,
+				action: this.getActionLabel( itemData ),
+				type: itemData.type,
+			} );
+
+			this.startItemTitle = '';
+			this.startItemAction = '';
+		}
+
+		currentItem.get( 'items' ).add( itemData, { at: 0 } );
+
+		this.items.add( currentItem, { at: 0 } );
+
+		this.updateCurrentItem( currentItem );
+
+		return id;
+	}
+
+	doItem( index ) {
+		// Don't track while restoring the item
+		this.setActive( false );
+
+		const item = this.items.at( index );
+
+		if ( 'not_applied' === item.get( 'status' ) ) {
+			this.undoItem( index );
+		} else {
+			this.redoItem( index );
+		}
+
+		this.setActive( true );
+
+		const panel = elementor.getPanelView(),
+			panelPage = panel.getCurrentPageView(),
+			editedElementView = panelPage.getOption( 'editedElementView' );
+
+		let viewToScroll;
+
+		if ( $e.routes.isPartOf( 'panel/editor' ) && editedElementView ) {
+			if ( editedElementView.isDestroyed ) {
+				// If the the element isn't exist - show the history panel
+				$e.route( 'panel/history/actions' );
+			} else {
+				// If element exist - render again, maybe the settings has been changed
+				viewToScroll = editedElementView;
+			}
+		} else if ( item instanceof Backbone.Model && item.get( 'items' ).length ) {
+			const historyItem = item.get( 'items' ).first();
+
+			if ( historyItem.get( 'restore' ) ) {
+				let container = 'sub-add' === historyItem.get( 'type' ) ?
+					historyItem.get( 'data' ).containerToRestore :
+					historyItem.get( 'container' ) || historyItem.get( 'containers' );
+
+				if ( Array.isArray( container ) ) {
+					container = container[ 0 ];
+				}
+
+				if ( container ) {
+					viewToScroll = container.lookup().view;
+				}
+			}
+		}
+
+		$e.internal( 'document/save/set-is-modified', {
+			status: item.get( 'id' ) !== this.document.editor.lastSaveHistoryId,
+		} );
+
+		this.updateCurrentItem( item );
+
+		if ( viewToScroll && ! elementor.helpers.isInViewport( viewToScroll.$el[ 0 ], elementor.$previewContents.find( 'html' )[ 0 ] ) ) {
+			elementor.helpers.scrollToView( viewToScroll.$el );
+		}
+	}
+
+	undoItem( index ) {
+		for ( let stepNum = 0; stepNum < index; stepNum++ ) {
+			const item = this.items.at( stepNum );
+
+			if ( 'not_applied' === item.get( 'status' ) ) {
+				item.get( 'items' ).each( function( subItem ) {
+					const restore = subItem.get( 'restore' );
+
+					if ( restore ) {
+						restore( subItem );
+					}
+				} );
+
+				item.set( 'status', 'applied' );
+			}
+		}
+	}
+
+	redoItem( index ) {
+		for ( let stepNum = this.items.length - 1; stepNum >= index; stepNum-- ) {
+			const item = this.items.at( stepNum );
+
+			if ( 'applied' === item.get( 'status' ) ) {
+				var reversedSubItems = _.toArray( item.get( 'items' ).models ).reverse();
+
+				_( reversedSubItems ).each( function( subItem ) {
+					const restore = subItem.get( 'restore' );
+
+					if ( restore ) {
+						restore( subItem, true );
+					}
+				} );
+
+				item.set( 'status', 'not_applied' );
+			}
+		}
+	}
+
+	updateCurrentItem( item ) {
+		// Save last selected item.
+		this.currentItem = item;
+
+		this.updatePanelPageCurrentItem();
+	}
+
+	updatePanelPageCurrentItem() {
+		if ( $e.routes.is( 'panel/history/actions' ) ) {
+			elementor.getPanelView().getCurrentPageView().getCurrentTab().updateCurrentItem();
+		}
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/history/panel-tab.js

@@ -0,0 +1,63 @@
+import ItemView from './item-view';
+import EmptyView from './empty';
+
+module.exports = Marionette.CompositeView.extend( {
+	id: 'elementor-panel-history',
+
+	template: '#tmpl-elementor-panel-history-tab',
+
+	childView: ItemView,
+
+	childViewContainer: '#elementor-history-list',
+
+	emptyView: EmptyView,
+
+	currentItem: null,
+
+	updateCurrentItem: function() {
+		if ( this.children.length <= 1 ) {
+			return;
+		}
+
+		_.defer( () => {
+			// Set current item - the first not applied item
+			const currentItem = this.collection.find( function( model ) {
+					return 'not_applied' === model.get( 'status' );
+				} ),
+				currentView = this.children.findByModel( currentItem );
+
+			if ( ! currentView ) {
+				return;
+			}
+
+			const currentItemClass = 'elementor-history-item-current';
+
+			if ( this.currentItem ) {
+				this.currentItem.removeClass( currentItemClass );
+			}
+
+			this.currentItem = currentView.$el;
+
+			this.currentItem.addClass( currentItemClass );
+		} );
+	},
+
+	onRender: function() {
+		this.updateCurrentItem();
+	},
+
+	onRenderEmpty: function() {
+		this.$el.addClass( 'elementor-empty' );
+	},
+
+	onChildviewClick: function( childView, event ) {
+		if ( childView.$el === this.currentItem ) {
+			return;
+		}
+
+		const collection = event.model.collection,
+			index = collection.findIndex( event.model );
+
+		$e.run( 'panel/history/actions/do', { index } );
+	},
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/module.js

@@ -0,0 +1,33 @@
+import Component from './component';
+import HistoryComponent from './history/component';
+import RevisionsComponent from './revisions/component';
+import PanelPage from './panel-page';
+
+export default class Manager {
+	constructor() {
+		elementorCommon.elements.$window.on( 'elementor:loaded', this.init );
+	}
+
+	init() {
+		$e.components.register( new Component() );
+		$e.components.register( new HistoryComponent() );
+		$e.components.register( new RevisionsComponent() );
+
+		elementor.on( 'panel:init', () => {
+			elementor.getPanelView().addPage( 'historyPage', {
+				view: PanelPage,
+				title: __( 'History', 'elementor' ),
+			} );
+		} );
+	}
+
+	get history() {
+		elementorCommon.helpers.softDeprecated( 'elementor.history.history', '2.9.0', 'elementor.documents.getCurrent().history' );
+		return elementor.documents.getCurrent().history;
+	}
+
+	get revisions() {
+		elementorCommon.helpers.softDeprecated( 'elementor.history.revisions', '2.9.0', 'elementor.documents.getCurrent().revisions' );
+		return elementor.documents.getCurrent().revisions;
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/panel-page.js

@@ -0,0 +1,84 @@
+var TabHistoryView = require( './history/panel-tab' );
+
+import TabRevisionsLoadingView from './revisions/panel/loading';
+import TabRevisionsView from './revisions/panel/tab';
+import TabRevisionsEmptyView from './revisions/panel/empty';
+
+module.exports = Marionette.LayoutView.extend( {
+	template: '#tmpl-elementor-panel-history-page',
+
+	regions: {
+		content: '#elementor-panel-history-content',
+	},
+
+	ui: {
+		tabs: '.elementor-panel-navigation-tab',
+	},
+
+	regionViews: {},
+
+	currentTab: null,
+
+	/**
+	 * @type {Document}
+	 */
+	document: null,
+
+	initialize: function( options ) {
+		this.document = options.document || elementor.documents.getCurrent();
+
+		this.initRegionViews();
+	},
+
+	initRegionViews: function() {
+		const historyItems = this.document.history.getItems();
+
+		this.regionViews = {
+			actions: {
+				view: () => {
+					return TabHistoryView;
+				},
+				options: {
+					collection: historyItems,
+					history: this.document.history,
+				},
+			},
+			revisions: {
+				view: () => {
+					const revisionsItems = this.document.revisions.getItems();
+
+					if ( ! revisionsItems ) {
+						return TabRevisionsLoadingView;
+					}
+
+					if ( 1 === revisionsItems.length && 'current' === revisionsItems.models[ 0 ].get( 'type' ) ) {
+						return TabRevisionsEmptyView;
+					}
+
+					return TabRevisionsView;
+				},
+				options: {
+					document: this.document,
+				},
+			},
+		};
+	},
+
+	getCurrentTab: function() {
+		return this.currentTab;
+	},
+
+	showView: function( viewName ) {
+		const viewDetails = this.regionViews[ viewName ],
+			options = viewDetails.options || {},
+			View = viewDetails.view();
+
+		if ( this.currentTab && this.currentTab.constructor === View ) {
+			return;
+		}
+
+		this.currentTab = new View( options );
+
+		this.content.show( this.currentTab );
+	},
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/collection.js

@@ -0,0 +1,8 @@
+var RevisionModel = require( './model' );
+
+module.exports = Backbone.Collection.extend( {
+	model: RevisionModel,
+	comparator: function( model ) {
+		return -model.get( 'timestamp' );
+	},
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/commands/down.js

@@ -0,0 +1,9 @@
+import CommandBase from 'elementor-api/modules/command-base';
+
+export class Down extends CommandBase {
+	apply() {
+		this.component.navigate();
+	}
+}
+
+export default Down;

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/commands/index.js

@@ -0,0 +1,2 @@
+export { Down } from './down';
+export { Up } from './up';

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/commands/up.js

@@ -0,0 +1,9 @@
+import CommandBase from 'elementor-api/modules/command-base';
+
+export class Up extends CommandBase {
+	apply() {
+		this.component.navigate( true );
+	}
+}
+
+export default Up;

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/component.js

@@ -0,0 +1,36 @@
+import ComponentBase from 'elementor-api/modules/component-base';
+import * as commands from './commands/';
+import * as hooks from './hooks/';
+
+export default class Component extends ComponentBase {
+	getNamespace() {
+		return 'panel/history/revisions';
+	}
+
+	defaultCommands() {
+		return this.importCommands( commands );
+	}
+
+	defaultHooks() {
+		return this.importHooks( hooks );
+	}
+
+	defaultShortcuts() {
+		return {
+			up: {
+				keys: 'up',
+				scopes: [ this.getNamespace() ],
+			},
+			down: {
+				keys: 'down',
+				scopes: [ this.getNamespace() ],
+			},
+		};
+	}
+
+	navigate( up ) {
+		if ( elementor.documents.getCurrent().revisions.getItems().length > 1 ) {
+			elementor.getPanelView().getCurrentPageView().currentTab.navigate( up );
+		}
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/hooks/data/save.js

@@ -0,0 +1,32 @@
+import HookDataAfter from 'elementor-api/modules/hooks/data/after';
+
+export class RevisionsAfterSave extends HookDataAfter {
+	getCommand() {
+		return 'document/save/save';
+	}
+
+	getId() {
+		return 'revisions-after-save';
+	}
+
+	apply( args, result ) {
+		const { data } = result,
+			revisionsModule = elementor.documents.getCurrent().revisions;
+
+		if ( data.latest_revisions ) {
+			revisionsModule.addRevisions( data.latest_revisions );
+		}
+
+		revisionsModule.requestRevisions( () => {
+			if ( data.revisions_ids ) {
+				const revisionsToKeep = revisionsModule.revisions.filter( ( revision ) => {
+					return -1 !== data.revisions_ids.indexOf( revision.get( 'id' ) );
+				} );
+
+				revisionsModule.revisions.reset( revisionsToKeep );
+			}
+		} );
+	}
+}
+
+export default RevisionsAfterSave;

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/hooks/index.js

@@ -0,0 +1 @@
+export { RevisionsAfterSave } from './data/save';

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/manager.js

@@ -0,0 +1,97 @@
+const RevisionsCollection = require( './collection' );
+
+/**
+ * TODO: consider refactor this class.
+ * TODO: Rename to RevisionsModule.
+ */
+export default class RevisionsManager {
+	document;
+	revisions;
+
+	constructor( document ) {
+		this.document = document;
+	}
+
+	getItems() {
+		return this.revisions;
+	}
+
+	requestRevisions( callback ) {
+		if ( this.revisions ) {
+			callback( this.revisions );
+
+			return;
+		}
+
+		elementorCommon.ajax.addRequest( 'get_revisions', {
+			success: ( data ) => {
+				this.revisions = new RevisionsCollection( data );
+
+				this.revisions.on( 'update', this.onRevisionsUpdate.bind( this ) );
+
+				callback( this.revisions );
+			},
+		} );
+	}
+
+	setEditorData( data ) {
+		const collection = elementor.getPreviewView().collection;
+
+		collection.reset( data );
+	}
+
+	getRevisionDataAsync( id, options ) {
+		_.extend( options, {
+			data: {
+				id: id,
+			},
+		} );
+
+		return elementorCommon.ajax.addRequest( 'get_revision_data', options );
+	}
+
+	addRevisions( items ) {
+		this.requestRevisions( () => {
+			items.forEach( ( item ) => {
+				const existedModel = this.revisions.findWhere( {
+					id: item.id,
+				} );
+
+				if ( existedModel ) {
+					this.revisions.remove( existedModel, { silent: true } );
+				}
+
+				this.revisions.add( item, { silent: true } );
+			} );
+
+			this.revisions.trigger( 'update' );
+		} );
+	}
+
+	deleteRevision( revisionModel, options ) {
+		const params = {
+			data: {
+				id: revisionModel.get( 'id' ),
+			},
+			success: () => {
+				if ( options.success ) {
+					options.success();
+				}
+
+				revisionModel.destroy();
+			},
+		};
+
+		if ( options.error ) {
+			params.error = options.error;
+		}
+
+		elementorCommon.ajax.addRequest( 'delete_revision', params );
+	}
+
+	onRevisionsUpdate() {
+		if ( $e.routes.is( 'panel/history/revisions' ) ) {
+			$e.routes.refreshContainer( 'panel' );
+		}
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/model.js

@@ -0,0 +1,9 @@
+var RevisionModel;
+
+RevisionModel = Backbone.Model.extend();
+
+RevisionModel.prototype.sync = function() {
+	return null;
+};
+
+module.exports = RevisionModel;

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/panel/empty.js

@@ -0,0 +1,5 @@
+module.exports = Marionette.ItemView.extend( {
+	template: '#tmpl-elementor-panel-revisions-no-revisions',
+	id: 'elementor-panel-revisions-no-revisions',
+	className: 'elementor-nerd-box',
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/panel/loading.js

@@ -0,0 +1,15 @@
+export default class extends Marionette.ItemView {
+	getTemplate() {
+		return '#tmpl-elementor-panel-revisions-loading';
+	}
+
+	id() {
+		return 'elementor-panel-revisions-loading';
+	}
+
+	onRender() {
+		this.options.document.revisions.requestRevisions( () => {
+			setTimeout( () => $e.routes.refreshContainer( 'panel' ) );
+		} );
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/panel/tab.js

@@ -0,0 +1,208 @@
+module.exports = Marionette.CompositeView.extend( {
+	id: 'elementor-panel-revisions',
+
+	template: '#tmpl-elementor-panel-revisions',
+
+	childView: require( './view' ),
+
+	childViewContainer: '#elementor-revisions-list',
+
+	ui: {
+		discard: '.elementor-panel-scheme-discard .elementor-button',
+		apply: '.elementor-panel-scheme-save .elementor-button',
+	},
+
+	events: {
+		'click @ui.discard': 'onDiscardClick',
+		'click @ui.apply': 'onApplyClick',
+	},
+
+	isRevisionApplied: false,
+
+	currentPreviewId: null,
+
+	currentPreviewItem: null,
+
+	document: null,
+
+	initialize: function( options ) {
+		this.document = options.document;
+
+		this.collection = this.document.revisions.getItems();
+
+		this.listenTo( elementor.channels.editor, 'saved', this.onEditorSaved );
+
+		this.currentPreviewId = elementor.config.document.revisions.current_id;
+	},
+
+	getRevisionViewData: function( revisionView ) {
+		this.document.revisions.getRevisionDataAsync( revisionView.model.get( 'id' ), {
+			success: ( data ) => {
+				if ( this.document.config.panel.has_elements ) {
+					this.document.revisions.setEditorData( data.elements );
+				}
+
+				elementor.settings.page.model.set( data.settings );
+
+				this.setRevisionsButtonsActive( true );
+
+				revisionView.$el.removeClass( 'elementor-revision-item-loading' );
+
+				this.enterReviewMode();
+			},
+			error: ( errorMessage ) => {
+				revisionView.$el.removeClass( 'elementor-revision-item-loading' );
+
+				this.currentPreviewItem = null;
+
+				this.currentPreviewId = null;
+
+				alert( errorMessage );
+			},
+		} );
+	},
+
+	setRevisionsButtonsActive: function( active ) {
+		// Check the tab is open.
+		if ( ! this.isDestroyed ) {
+			this.ui.apply.add( this.ui.discard ).prop( 'disabled', ! active );
+		}
+	},
+
+	deleteRevision: function( revisionView ) {
+		revisionView.$el.addClass( 'elementor-revision-item-loading' );
+
+		this.document.revisions.deleteRevision( revisionView.model, {
+			success: () => {
+				if ( revisionView.model.get( 'id' ) === this.currentPreviewId ) {
+					this.onDiscardClick();
+				}
+
+				this.currentPreviewId = null;
+			},
+			error: () => {
+				revisionView.$el.removeClass( 'elementor-revision-item-loading' );
+
+				alert( 'An error occurred' );
+			},
+		} );
+	},
+
+	enterReviewMode: function() {
+		elementor.changeEditMode( 'review' );
+	},
+
+	exitReviewMode: function() {
+		elementor.changeEditMode( 'edit' );
+	},
+
+	navigate: function( reverse ) {
+		if ( ! this.currentPreviewId || ! this.currentPreviewItem || this.children.length <= 1 ) {
+			return;
+		}
+
+		var currentPreviewItemIndex = this.collection.indexOf( this.currentPreviewItem.model ),
+			requiredIndex = reverse ? currentPreviewItemIndex - 1 : currentPreviewItemIndex + 1;
+
+		if ( requiredIndex < 0 ) {
+			requiredIndex = this.collection.length - 1;
+		}
+
+		if ( requiredIndex >= this.collection.length ) {
+			requiredIndex = 0;
+		}
+
+		this.children.findByIndex( requiredIndex ).ui.detailsArea.trigger( 'click' );
+	},
+
+	onEditorSaved: function() {
+		this.exitReviewMode();
+
+		this.setRevisionsButtonsActive( false );
+
+		this.currentPreviewId = elementor.config.document.revisions.current_id;
+	},
+
+	onApplyClick: function() {
+		$e.internal( 'document/save/set-is-modified', { status: true } );
+
+		$e.run( 'document/save/auto', { force: true } );
+
+		this.isRevisionApplied = true;
+
+		this.currentPreviewId = null;
+
+		this.document.history.getItems().reset();
+	},
+
+	onDiscardClick: function() {
+		if ( this.document.config.panel.has_elements ) {
+			this.document.revisions.setEditorData( elementor.config.document.elements );
+		}
+
+		$e.internal( 'document/save/set-is-modified', { status: this.isRevisionApplied } );
+
+		this.isRevisionApplied = false;
+
+		this.setRevisionsButtonsActive( false );
+
+		this.currentPreviewId = null;
+
+		this.exitReviewMode();
+
+		if ( this.currentPreviewItem ) {
+			this.currentPreviewItem.$el.removeClass( 'elementor-revision-current-preview' );
+		}
+	},
+
+	onDestroy: function() {
+		if ( this.currentPreviewId && this.currentPreviewId !== elementor.config.document.revisions.current_id ) {
+			this.onDiscardClick();
+		}
+	},
+
+	onRenderCollection: function() {
+		if ( ! this.currentPreviewId ) {
+			return;
+		}
+
+		var currentPreviewModel = this.collection.findWhere( { id: this.currentPreviewId } );
+
+		// Ensure the model is exist and not deleted during a save.
+		if ( currentPreviewModel ) {
+			this.currentPreviewItem = this.children.findByModelCid( currentPreviewModel.cid );
+			this.currentPreviewItem.$el.addClass( 'elementor-revision-current-preview' );
+		}
+	},
+
+	onChildviewDetailsAreaClick: function( childView ) {
+		const revisionID = childView.model.get( 'id' );
+
+		if ( revisionID === this.currentPreviewId ) {
+			return;
+		}
+
+		if ( this.currentPreviewItem ) {
+			this.currentPreviewItem.$el.removeClass( 'elementor-revision-current-preview elementor-revision-item-loading' );
+		}
+
+		childView.$el.addClass( 'elementor-revision-current-preview elementor-revision-item-loading' );
+
+		const revision = ( null === this.currentPreviewId || elementor.config.document.revisions.current_id === this.currentPreviewId );
+
+		if ( revision && elementor.saver.isEditorChanged() ) {
+			// TODO: Change to 'document/save/auto' ?.
+			$e.internal( 'document/save/save', {
+				status: 'autosave',
+				onSuccess: () => {
+					this.getRevisionViewData( childView );
+				},
+			} );
+		} else {
+			this.getRevisionViewData( childView );
+		}
+
+		this.currentPreviewItem = childView;
+		this.currentPreviewId = revisionID;
+	},
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/js/revisions/panel/view.js

@@ -0,0 +1,13 @@
+module.exports = Marionette.ItemView.extend( {
+	template: '#tmpl-elementor-panel-revisions-revision-item',
+
+	className: 'elementor-revision-item',
+
+	ui: {
+		detailsArea: '.elementor-revision-item__details',
+	},
+
+	triggers: {
+		'click @ui.detailsArea': 'detailsArea:click',
+	},
+} );

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/scss/_history.scss

@@ -0,0 +1,91 @@
+.elementor-history- {
+
+	&item {
+		display: flex;
+		align-items: center;
+		border: 1px solid $editor-lightest;
+		padding: 10px 15px;
+		margin-bottom: 10px;
+		font-size: 11px;
+		line-height: 1.4;
+		cursor: pointer;
+		transition: $transition-hover;
+
+		&:hover {
+			background-color: fade_out($editor-background, 0.7) ;
+
+			.elementor-history-item__icon{
+				.eicon:before {
+					content:'\e924';
+				}
+			}
+		}
+
+		&-applied {
+			color: $editor-light;
+		}
+
+		&-current {
+			background: $editor-background;
+			cursor: default;
+
+			.elementor-history-item__icon, &:hover .elementor-history-item__icon{
+				.eicon:before {
+					content:'\e90e';
+				}
+			}
+		}
+
+		&__details{
+			width: 95%;
+		}
+
+		&__title {
+			font-weight: bold;
+		}
+
+		&__subtitle, &__action {
+			font-weight: lighter;
+		}
+
+		&__action {
+			font-style: italic;
+			text-decoration: underline;
+		}
+
+		.__icon {
+			 float: $end;
+		 }
+	}
+
+	&revisions-message{
+		font-size: 11px;
+		text-align: center;
+		padding-top: 5px;
+	}
+}
+
+#elementor-panel-history {
+	padding: 20px 20px 15px;
+
+	&.elementor-empty {
+
+		.elementor-history-revisions-message {
+			padding-top: 20px;
+		}
+	}
+
+	&:not(.elementor-empty) {
+		background-color: #fff;
+		margin-top: 10px;
+	}
+}
+
+#elementor-panel-history-no-items,
+#elementor-panel-revisions-no-revisions {
+	text-align: center;
+
+	.elementor-nerd-box-icon {
+		margin-top: 20px;
+	}
+}

wp-content/plugins/elementor-3.2.5-bck4/modules/history/assets/scss/_revisions.scss

@@ -0,0 +1,78 @@
+.elementor-revision- {
+
+	&item {
+		&__wrapper {
+			display: flex;
+			align-items: center;
+			border: 1px solid $editor-lightest;
+			padding: 10px 15px;
+			margin-bottom: 10px;
+			font-size: 11px;
+			transition: $transition-hover;
+
+			&.current {
+				font-weight: bold;
+			}
+
+			.elementor-revision-item__tools-current {
+				color: $editor-info
+			}
+		}
+
+		&:hover:not(.elementor-revision-current-preview) {
+			background-color: fade_out($editor-background, 0.7) ;
+		}
+
+		&-loading {
+
+			.elementor-revision-item__tools-current {
+				display: none;
+			}
+		}
+
+		&:not(.elementor-revision-item-loading) {
+
+			.elementor-revision-item__tools-spinner {
+				display: none;
+			}
+		}
+
+		&__gravatar {
+			border-radius: 50%;
+			overflow: hidden;
+
+			img {
+				display: block;
+			}
+		}
+
+		&__details {
+			@include padding-start(15px);
+			flex-grow: 1;
+			cursor: pointer;
+		}
+	}
+
+	&meta {
+		padding-top: 5px;
+		font-size: 10px;
+		font-weight: bold;
+	}
+
+	&current-preview {
+		background-color: $editor-background;
+	}
+}
+
+#elementor-restore-autosave-dialog.dialog-widget {
+	background-color: rgba(0, 0, 0, 0.3);
+}
+
+#elementor-panel-revisions-loading {
+	@include absolute-center;
+
+	.eicon-loading {
+		font-size: 50px;
+		color: $editor-light;
+	}
+}