diff --git a/src/js/_enqueues/lib/nav-menu.js b/src/js/_enqueues/lib/nav-menu.js
index 5e94a2b34f3c9..f27c38778790d 100644
--- a/src/js/_enqueues/lib/nav-menu.js
+++ b/src/js/_enqueues/lib/nav-menu.js
@@ -844,12 +844,74 @@
} );
},
+ /**
+ * Creates a saver that sends screen option updates in order.
+ *
+ * @since 7.2.0
+ * @private
+ *
+ * @param {Function} getData Gets the current screen option request data.
+ * @param {Function} [success] Handles a successful request.
+ * @return {Function} Saves the current state after any active request, with
+ * a whenIdle() method to wait for queued requests to settle.
+ */
+ createScreenOptionsSaver : function( getData, success ) {
+ var saving = false,
+ pending = false,
+ idle = $.Deferred().resolve();
+
+ function save() {
+ if ( saving ) {
+ pending = true;
+ return;
+ }
+
+ pending = false;
+ saving = true;
+
+ if ( 'pending' !== idle.state() ) {
+ idle = $.Deferred();
+ }
+
+ $.post( ajaxurl, getData(), success ).always( function() {
+ saving = false;
+
+ if ( pending ) {
+ save();
+ } else {
+ idle.resolve();
+ }
+ } );
+ }
+
+ /**
+ * Waits for the active request and any queued updates to settle.
+ *
+ * @return {JQuery.Promise} A promise that resolves when the saver is idle.
+ */
+ save.whenIdle = function() {
+ return idle.promise();
+ };
+
+ return save;
+ },
+
initToggles : function() {
// Init postboxes.
postboxes.add_postbox_toggles('nav-menus');
// Adjust columns functions for menus UI.
columns.useCheckboxesForHidden();
+ columns.saveManageColumnsState = api.createScreenOptionsSaver( function() {
+ return {
+ action: 'hidden-columns',
+ hidden: columns.hidden(),
+ screenoptionnonce: $( '#screenoptionnonce' ).val(),
+ page: 'nav-menus'
+ };
+ }, function() {
+ wp.a11y.speak( wp.i18n.__( 'Screen Options updated.' ) );
+ } );
columns.checked = function(field) {
$('.field-' + field).removeClass('hidden-field');
};
@@ -859,15 +921,17 @@
// Hide fields.
api.menuList.hideAdvancedMenuItemFields();
- $('.hide-postbox-tog').on( 'click', function () {
- var hidden = $( '.accordion-container li.accordion-section' ).filter(':hidden').map(function() { return this.id; }).get().join(',');
- $.post(ajaxurl, {
+ api.saveMenuBoxesState = api.createScreenOptionsSaver( function() {
+ return {
action: 'closed-postboxes',
- hidden: hidden,
- closedpostboxesnonce: jQuery('#closedpostboxesnonce').val(),
+ hidden: $( '.accordion-container li.accordion-section' ).filter( ':hidden' ).map( function() {
+ return this.id;
+ } ).get().join( ',' ),
+ closedpostboxesnonce: $( '#closedpostboxesnonce' ).val(),
page: 'nav-menus'
- });
- });
+ };
+ } );
+ $( '.hide-postbox-tog' ).on( 'click', api.saveMenuBoxesState );
},
initSortables : function() {
@@ -1377,13 +1441,61 @@
},
attachMenuSaveSubmitListeners : function() {
+ var waiting = false;
+
/*
* When a navigation menu is saved, store a JSON representation of all form data
* in a single input to avoid PHP `max_input_vars` limitations. See #14134.
*/
- $( '#update-nav-menu' ).on( 'submit', function() {
- var navMenuData = $( '#update-nav-menu' ).serializeArray();
- $( '[name="nav-menu-data"]' ).val( JSON.stringify( navMenuData ) );
+ $( '#update-nav-menu' ).on( 'submit', function( event ) {
+ var form = this,
+ $form = $( form ),
+ columnsSaved, boxesSaved, submitter, $saveButtons, navMenuData;
+
+ if ( event.isDefaultPrevented() ) {
+ return;
+ }
+
+ columnsSaved = columns.saveManageColumnsState.whenIdle();
+ boxesSaved = api.saveMenuBoxesState.whenIdle();
+
+ if ( 'pending' === columnsSaved.state() || 'pending' === boxesSaved.state() ) {
+ event.preventDefault();
+
+ if ( waiting ) {
+ return;
+ }
+
+ waiting = true;
+ submitter = event.originalEvent && event.originalEvent.submitter;
+ $saveButtons = $form.find( '.menu-save:enabled' ).prop( 'disabled', true );
+ $form.attr( 'aria-busy', 'true' );
+
+ $.when( columnsSaved, boxesSaved ).done( function() {
+ waiting = false;
+ $saveButtons.prop( 'disabled', false );
+ $form.attr( 'aria-busy', 'false' );
+
+ // Recheck the queues and preserve native validation and the submit button.
+ if ( submitter && submitter.form === form ) {
+ form.requestSubmit( submitter );
+ } else {
+ form.requestSubmit();
+ }
+ } );
+ return;
+ }
+
+ if ( ! api.validateMenuName() ) {
+ event.preventDefault();
+ return;
+ }
+
+ // Include menu edits made while the screen options were being saved.
+ api.menuList.find( '.menu-item-data-position' ).val( function( index ) { return index + 1; } );
+ navMenuData = $form.serializeArray();
+ $form.find( '[name="nav-menu-data"]' ).val( JSON.stringify( navMenuData ) );
+ window.onbeforeunload = null;
});
},
@@ -1742,7 +1854,15 @@
return false;
},
- eventOnClickMenuSave : function() {
+ /**
+ * Validates the menu name before saving.
+ *
+ * @since 7.2.0
+ * @private
+ *
+ * @return {boolean} Whether the menu name contains non-whitespace characters.
+ */
+ validateMenuName : function() {
var menuName = $('#menu-name'),
menuNameVal = menuName.val();
@@ -1751,6 +1871,14 @@
menuName.parent().addClass( 'form-invalid' );
return false;
}
+ return true;
+ },
+
+ eventOnClickMenuSave : function() {
+ if ( ! api.validateMenuName() ) {
+ return false;
+ }
+
// Copy menu theme locations.
// Note: This appears to be dead code since #nav-menu-theme-locations no longer exists, perhaps removed in r32842.
var $updateNavMenu = $('#update-nav-menu');
@@ -1763,10 +1891,6 @@
} )
);
});
- // Update menu item position data.
- api.menuList.find('.menu-item-data-position').val( function(index) { return index + 1; } );
- window.onbeforeunload = null;
-
return true;
},
diff --git a/tests/qunit/wp-admin/js/nav-menu.js b/tests/qunit/wp-admin/js/nav-menu.js
index c630d078297de..9b277f8420719 100644
--- a/tests/qunit/wp-admin/js/nav-menu.js
+++ b/tests/qunit/wp-admin/js/nav-menu.js
@@ -1,4 +1,4 @@
-/*global wpNavMenu */
+/* global wpNavMenu, postboxes, wp, sinon */
( function( QUnit, $ ) {
QUnit.module( 'nav-menu' );
var assert,
@@ -92,5 +92,391 @@
} );
+ QUnit.module( 'nav-menu screen options', {
+ beforeEach: function() {
+ var requests = this.requests = [];
+
+ this.sandbox = sinon.createSandbox();
+ this.originalColumns = window.columns;
+ this.originalAjaxurl = window.ajaxurl;
+ this.originalSaveMenuBoxesState = wpNavMenu.saveMenuBoxesState;
+ this.originalBeforeUnload = window.onbeforeunload;
+
+ window.ajaxurl = '/wp-admin/admin-ajax.php';
+ window.columns = {
+ useCheckboxesForHidden: this.sandbox.stub(),
+ hidden: this.sandbox.stub().returns( '' ),
+ saveManageColumnsState: this.sandbox.stub()
+ };
+
+ $( '#qunit-fixture' ).append(
+ '' +
+ '' +
+ '' +
+ '' +
+ '
' +
+ '- Pages
' +
+ '- Custom Links
' +
+ '
' +
+ ''
+ );
+
+ this.sandbox.stub( $, 'post' ).callsFake( function( url, data, success ) {
+ var deferred = $.Deferred();
+
+ if ( success ) {
+ deferred.done( success );
+ }
+
+ requests.push( { url: url, data: data, deferred: deferred } );
+ return deferred.promise();
+ } );
+ this.speak = this.sandbox.stub( wp.a11y, 'speak' );
+ this.sandbox.stub( postboxes, 'add_postbox_toggles' );
+ this.sandbox.stub( wpNavMenu, 'menuList' ).value( {
+ hideAdvancedMenuItemFields: this.sandbox.stub(),
+ find: this.sandbox.stub().returns( $() )
+ } );
+
+ wpNavMenu.initToggles();
+
+ this.form = $( '#update-nav-menu' )[ 0 ];
+ this.saveButton = $( '.menu-save', this.form )[ 0 ];
+ this.submitMenu = function( submitter ) {
+ var event = new window.SubmitEvent( 'submit', {
+ bubbles: true,
+ cancelable: true,
+ submitter: submitter || this.saveButton
+ } );
+
+ this.form.dispatchEvent( event );
+ return event;
+ }.bind( this );
+ this.requestSubmit = this.sandbox.stub( this.form, 'requestSubmit' ).callsFake( this.submitMenu );
+ wpNavMenu.attachMenuSaveSubmitListeners();
+ },
+
+ afterEach: function() {
+ this.sandbox.restore();
+ window.onbeforeunload = this.originalBeforeUnload;
+
+ if ( undefined === this.originalSaveMenuBoxesState ) {
+ delete wpNavMenu.saveMenuBoxesState;
+ } else {
+ wpNavMenu.saveMenuBoxesState = this.originalSaveMenuBoxesState;
+ }
+
+ if ( undefined === this.originalColumns ) {
+ delete window.columns;
+ } else {
+ window.columns = this.originalColumns;
+ }
+
+ if ( undefined === this.originalAjaxurl ) {
+ delete window.ajaxurl;
+ } else {
+ window.ajaxurl = this.originalAjaxurl;
+ }
+ }
+ } );
+
+ QUnit.test( 'Advanced properties wait for the active save and send the latest state', function( assert ) {
+ window.columns.hidden.returns( 'link-target' );
+ window.columns.saveManageColumnsState();
+
+ assert.strictEqual( this.requests.length, 1, 'The first change is saved immediately.' );
+ assert.deepEqual( this.requests[ 0 ].data, {
+ action: 'hidden-columns',
+ hidden: 'link-target',
+ screenoptionnonce: 'columns-nonce',
+ page: 'nav-menus'
+ }, 'The advanced properties use the hidden-columns action.' );
+
+ window.columns.hidden.returns( 'link-target,title-attribute' );
+ window.columns.saveManageColumnsState();
+ window.columns.hidden.returns( 'title-attribute' );
+ window.columns.saveManageColumnsState();
+
+ assert.strictEqual( this.requests.length, 1, 'Rapid changes do not start overlapping saves.' );
+
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 2, 'Pending changes are coalesced into one save.' );
+ assert.strictEqual( this.requests[ 1 ].data.hidden, 'title-attribute', 'The final selection is sent.' );
+
+ this.requests[ 1 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 2, 'There are no redundant saves.' );
+ assert.strictEqual( this.speak.callCount, 2, 'Successful saves retain the accessibility announcement.' );
+ } );
+
+ QUnit.test( 'Boxes wait for the active save and collect the latest visibility', function( assert ) {
+ $( '#add-post-type-page' ).hide();
+ $( '.hide-postbox-tog' ).first().triggerHandler( 'click' );
+
+ assert.strictEqual( this.requests.length, 1, 'The first change is saved immediately.' );
+ assert.deepEqual( this.requests[ 0 ].data, {
+ action: 'closed-postboxes',
+ hidden: 'add-post-type-page',
+ closedpostboxesnonce: 'postboxes-nonce',
+ page: 'nav-menus'
+ }, 'Boxes use the closed-postboxes action.' );
+
+ $( '#add-custom-links' ).hide();
+ $( '.hide-postbox-tog' ).last().triggerHandler( 'click' );
+
+ assert.strictEqual( this.requests.length, 1, 'The second change waits for the first response.' );
+
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 2, 'The pending change is saved after the response.' );
+ assert.strictEqual( this.requests[ 1 ].data.hidden, 'add-post-type-page,add-custom-links', 'Both hidden boxes are saved.' );
+ } );
+
+ QUnit.test( 'Showing all advanced properties sends an empty hidden list', function( assert ) {
+ window.columns.hidden.returns( 'link-target' );
+ window.columns.saveManageColumnsState();
+ window.columns.hidden.returns( '' );
+ window.columns.saveManageColumnsState();
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 2, 'Clearing the list is saved.' );
+ assert.strictEqual( this.requests[ 1 ].data.hidden, '', 'An empty list is not discarded.' );
+ } );
+
+ QUnit.test( 'Changes made during a follow-up save are also persisted', function( assert ) {
+ window.columns.hidden.returns( 'link-target' );
+ window.columns.saveManageColumnsState();
+ window.columns.hidden.returns( 'title-attribute' );
+ window.columns.saveManageColumnsState();
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ window.columns.hidden.returns( 'description' );
+ window.columns.saveManageColumnsState();
+
+ assert.strictEqual( this.requests.length, 2, 'The follow-up save also prevents overlapping requests.' );
+
+ this.requests[ 1 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 3, 'The next change is saved when the follow-up completes.' );
+ assert.strictEqual( this.requests[ 2 ].data.hidden, 'description', 'The most recent state is sent.' );
+ } );
+
+ QUnit.test( 'A failed request releases pending changes without announcing success', function( assert ) {
+ window.columns.hidden.returns( 'link-target' );
+ window.columns.saveManageColumnsState();
+ window.columns.hidden.returns( 'title-attribute' );
+ window.columns.saveManageColumnsState();
+ this.requests[ 0 ].deferred.reject();
+
+ assert.strictEqual( this.requests.length, 2, 'The failed request does not strand pending changes.' );
+ assert.strictEqual( this.requests[ 1 ].data.hidden, 'title-attribute', 'Recovery sends the latest selection.' );
+ assert.strictEqual( this.speak.callCount, 0, 'Failure does not announce a successful save.' );
+
+ this.requests[ 1 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.speak.callCount, 1, 'The successful follow-up is announced.' );
+ } );
+
+ QUnit.test( 'An isolated change completes without starting another request', function( assert ) {
+ window.columns.saveManageColumnsState();
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 1, 'Completion alone does not schedule another save.' );
+
+ window.columns.saveManageColumnsState();
+
+ assert.strictEqual( this.requests.length, 2, 'A later change can start a new save immediately.' );
+ } );
+
+ QUnit.test( 'Boxes and advanced properties have independent save queues', function( assert ) {
+ window.columns.saveManageColumnsState();
+ $( '.hide-postbox-tog' ).first().triggerHandler( 'click' );
+
+ assert.strictEqual( this.requests.length, 2, 'Each preference can have one active request.' );
+
+ window.columns.hidden.returns( 'link-target' );
+ window.columns.saveManageColumnsState();
+ $( '#add-custom-links' ).hide();
+ $( '.hide-postbox-tog' ).last().triggerHandler( 'click' );
+
+ assert.strictEqual( this.requests.length, 2, 'Each preference retains its pending change.' );
+
+ this.requests[ 1 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 3, 'Completing Boxes releases only the Boxes queue.' );
+ assert.strictEqual( this.requests[ 2 ].data.action, 'closed-postboxes' );
+ assert.strictEqual( this.requests[ 2 ].data.hidden, 'add-custom-links' );
+
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requests.length, 4, 'Completing advanced properties releases their queue.' );
+ assert.strictEqual( this.requests[ 3 ].data.action, 'hidden-columns' );
+ assert.strictEqual( this.requests[ 3 ].data.hidden, 'link-target' );
+ } );
+
+ QUnit.test( 'Save Menu waits for both queues, including their follow-up requests', function( assert ) {
+ window.columns.hidden.returns( 'link-target' );
+ window.columns.saveManageColumnsState();
+ $( '.hide-postbox-tog' ).first().triggerHandler( 'click' );
+ window.columns.hidden.returns( 'link-target,title-attribute' );
+ window.columns.saveManageColumnsState();
+ $( '#add-custom-links' ).hide();
+ $( '.hide-postbox-tog' ).last().triggerHandler( 'click' );
+
+ assert.true( this.submitMenu().defaultPrevented, 'Submission waits while preferences are being saved.' );
+ assert.true( this.saveButton.disabled, 'Save Menu indicates that the submission is waiting.' );
+ assert.strictEqual( $( this.form ).attr( 'aria-busy' ), 'true' );
+ assert.strictEqual( $( '[name="nav-menu-data"]', this.form ).val(), '', 'Menu data is not serialized before the wait.' );
+
+ this.requests[ 0 ].deferred.resolve( '1' );
+ assert.strictEqual( this.requests[ 2 ].data.hidden, 'link-target,title-attribute' );
+ this.requests[ 2 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requestSubmit.callCount, 0, 'The other queue must also finish.' );
+
+ this.requests[ 1 ].deferred.resolve( '1' );
+ assert.strictEqual( this.requests[ 3 ].data.hidden, 'add-custom-links' );
+ this.requests[ 3 ].deferred.resolve( '1' );
+
+ assert.true( this.requestSubmit.calledOnceWithExactly( this.saveButton ), 'The original submit button is preserved.' );
+ assert.false( this.requestSubmit.firstCall.returnValue.defaultPrevented, 'The resumed submission proceeds.' );
+ assert.false( this.saveButton.disabled, 'The button is restored before resuming submission.' );
+ assert.strictEqual( $( this.form ).attr( 'aria-busy' ), 'false' );
+ assert.deepEqual( JSON.parse( $( '[name="nav-menu-data"]', this.form ).val() ), [
+ { name: 'action', value: 'update' },
+ { name: 'menu-name', value: 'Test menu' },
+ { name: 'nav-menu-data', value: '' }
+ ], 'Menu data is serialized once after the preference saves finish.' );
+ } );
+
+ QUnit.test( 'Save Menu waits for an active save even without a queued change', function( assert ) {
+ window.columns.saveManageColumnsState();
+
+ assert.true( this.submitMenu().defaultPrevented );
+
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requestSubmit.callCount, 1 );
+ assert.false( this.requestSubmit.firstCall.returnValue.defaultPrevented );
+ } );
+
+ QUnit.test( 'Save Menu rechecks a queue that becomes active again during the wait', function( assert ) {
+ window.columns.saveManageColumnsState();
+ $( '.hide-postbox-tog' ).first().triggerHandler( 'click' );
+ this.submitMenu();
+ this.requests[ 0 ].deferred.resolve( '1' );
+ window.columns.hidden.returns( 'description' );
+ window.columns.saveManageColumnsState();
+ this.requests[ 1 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requestSubmit.callCount, 1 );
+ assert.true( this.requestSubmit.firstCall.returnValue.defaultPrevented, 'The newly active save prevents navigation.' );
+ assert.strictEqual( $( '[name="nav-menu-data"]', this.form ).val(), '', 'Menu serialization still waits.' );
+
+ this.requests[ 2 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requestSubmit.callCount, 2 );
+ assert.false( this.requestSubmit.secondCall.returnValue.defaultPrevented, 'Only the final attempt can navigate.' );
+ } );
+
+ QUnit.test( 'Repeated submit events while saving resume the form only once', function( assert ) {
+ window.columns.saveManageColumnsState();
+
+ assert.true( this.submitMenu().defaultPrevented );
+ assert.true( this.submitMenu().defaultPrevented );
+
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requestSubmit.callCount, 1 );
+ } );
+
+ QUnit.test( 'A failed preference save does not leave Save Menu disabled', function( assert ) {
+ var disabledButton = $( '' ).appendTo( this.form )[ 0 ];
+
+ window.columns.saveManageColumnsState();
+ this.submitMenu();
+ this.requests[ 0 ].deferred.reject();
+
+ assert.strictEqual( this.requestSubmit.callCount, 1, 'The menu submission is released after the failure.' );
+ assert.false( this.saveButton.disabled, 'The active button is restored.' );
+ assert.true( disabledButton.disabled, 'A button disabled before submission stays disabled.' );
+ assert.strictEqual( this.speak.callCount, 0, 'The failed preference save is not announced as successful.' );
+ } );
+
+ QUnit.test( 'Save Menu submits immediately when both preference queues are idle', function( assert ) {
+ assert.false( this.submitMenu().defaultPrevented );
+ assert.strictEqual( this.requestSubmit.callCount, 0, 'An idle form does not need to be resubmitted.' );
+ assert.false( this.saveButton.disabled );
+ } );
+
+ QUnit.test( 'An already canceled submission is not resumed after preference saves', function( assert ) {
+ var event = new window.SubmitEvent( 'submit', { bubbles: true, cancelable: true } );
+
+ window.columns.saveManageColumnsState();
+ event.preventDefault();
+ this.form.dispatchEvent( event );
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( this.requestSubmit.callCount, 0, 'Another handler can cancel submission.' );
+ } );
+
+ QUnit.test( 'Deferred submission retains the unsaved-changes warning and refreshes item positions', function( assert ) {
+ var beforeUnload = function() { return 'Unsaved menu changes'; },
+ positions = $( '' ).appendTo( this.form );
+
+ wpNavMenu.menuList.find.returns( positions );
+ window.onbeforeunload = beforeUnload;
+ window.columns.saveManageColumnsState();
+ wpNavMenu.eventOnClickMenuSave();
+ this.submitMenu();
+
+ assert.strictEqual( window.onbeforeunload, beforeUnload, 'The warning stays active while submission waits.' );
+
+ positions = positions.add( $( '' ).appendTo( this.form ) );
+ wpNavMenu.menuList.find.returns( positions );
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.deepEqual( positions.map( function() { return this.value; } ).get(), [ '1', '2' ], 'Positions reflect edits made during the wait.' );
+ assert.strictEqual( window.onbeforeunload, null, 'The warning clears when the menu is ready to submit.' );
+ } );
+
+ QUnit.test( 'Native resubmission validates the current menu name and preserves the submitter', function( assert ) {
+ var submissions = 0,
+ submitter;
+
+ this.requestSubmit.restore();
+ this.form.addEventListener( 'submit', function( event ) {
+ if ( ! event.defaultPrevented ) {
+ submissions++;
+ submitter = event.submitter;
+ event.preventDefault();
+ }
+ } );
+
+ window.columns.saveManageColumnsState();
+ this.form.requestSubmit( this.saveButton );
+ $( '#menu-name' ).val( '' );
+ this.requests[ 0 ].deferred.resolve( '1' );
+
+ assert.strictEqual( submissions, 0, 'Native validation stops submission if the menu name was cleared during the wait.' );
+ assert.false( this.saveButton.disabled, 'The user can correct the name and submit again.' );
+
+ $( '#menu-name' ).val( ' ' );
+ this.form.requestSubmit( this.saveButton );
+
+ assert.strictEqual( submissions, 0, 'The existing whitespace-only name validation is also retained.' );
+
+ $( '#menu-name' ).val( 'Updated menu' );
+ this.form.requestSubmit( this.saveButton );
+
+ assert.strictEqual( submissions, 1, 'A valid menu can be submitted after correction.' );
+ assert.strictEqual( submitter, this.saveButton, 'Native submission keeps the original Save Menu button.' );
+ } );
} )( window.QUnit, jQuery );