Ticket #36944: 36944.0.wip.diff

src/wp-admin/js/customize-controls.js

@@ -1543 +1543 @@
 
                                         control.setting = control.settings['default'] || null;
 
+                                        // Add setting notifications to the control notification.
                                         _.each( control.settings, function( setting ) {
                                                 setting.notifications.bind( 'add', function( settingNotification ) {
-                                                        var controlNotification = new api.Notification( setting.id + ':' + settingNotification.code, settingNotification );
+                                                        var controlNotification, code, params;
+                                                        code = setting.id + ':' + settingNotification.code;
+                                                        params = _.extend(
+                                                                {},
+                                                                settingNotification,
+                                                                {
+                                                                        setting: setting.id
+                                                                }
+                                                        );
+                                                        controlNotification = new api.Notification( code, params );
                                                         control.notifications.add( controlNotification.code, controlNotification );
                                                 } );
                                                 setting.notifications.bind( 'remove', function( settingNotification ) {
@@ -3431 +3441 @@
                         },
 
                         /**
-                         * Handle invalid_settings in an error response for the customize-save request.
+                         * Handle setting_validities in an error response for the customize-save request.
                          *
                          * Add notifications to the settings and focus on the first control that has an invalid setting.
                          *
                          * @since 4.6.0
                          * @private
                          *
-                         * @param {object} response
-                         * @param {object} response.invalid_settings
+                         * @param {object}  options
+                         * @param {object}  options.settingValidities
+                         * @param {boolean} [options.focusInvalidControl=false]
                          * @returns {void}
                          */
-                        _handleInvalidSettingsError: function( response ) {
-                                var invalidControls = [], wasFocused = false;
-                                if ( _.isEmpty( response.invalid_settings ) ) {
-                                        return;
-                                }
+                        _handleSettingValidities: function( options ) {
+                                var invalidSettingControls, invalidSettings = [], wasFocused = false;
 
                                 // Find the controls that correspond to each invalid setting.
-                                _.each( response.invalid_settings, function( notifications, settingId ) {
+                                _.each( options.settingValidities, function( validity, settingId ) {
                                         var setting = api( settingId );
                                         if ( setting ) {
-                                                _.each( notifications, function( notificationParams, code ) {
-                                                        var notification = new api.Notification( code, notificationParams );
-                                                        setting.notifications.add( code, notification );
+
+                                                // Add notifications for invalidities.
+                                                if ( _.isObject( validity ) ) {
+                                                        _.each( validity, function( params, code ) {
+                                                                var notification = new api.Notification( code, params ), existingNotification, needsReplacement = false;
+
+                                                                // Remove existing notification if already exists for code but differs in parameters.
+                                                                existingNotification = setting.notifications( notification.code );
+                                                                if ( existingNotification ) {
+                                                                        needsReplacement = ( notification.type !== existingNotification.type ) || ! _.isEqual( notification.data, existingNotification.data );
+                                                                }
+                                                                if ( needsReplacement ) {
+                                                                        setting.notifications.remove( code );
+                                                                }
+
+                                                                if ( ! setting.notifications.has( notification.code ) ) {
+                                                                        setting.notifications.add( code, notification );
+                                                                }
+                                                                invalidSettings.push( setting.id );
+                                                        } );
+                                                }
+
+                                                // Remove notification errors that are no longer valid.
+                                                setting.notifications.each( function( notification ) {
+                                                        if ( 'error' === notification.type && ( true === validity || ! validity[ notification.code ] ) ) {
+                                                                setting.notifications.remove( notification.code );
+                                                        }
                                                 } );
                                         }
+                                } );
+
+                                if ( options && options.focusInvalidControl ) {
+                                        invalidSettingControls = api.findControlsForSettings( invalidSettings );
 
-                                        api.control.each( function( control ) {
-                                                _.each( control.settings, function( controlSetting ) {
-                                                        if ( controlSetting.id === settingId ) {
-                                                                invalidControls.push( control );
+                                        // Focus on the first control that is inside of an expanded section (one that is visible).
+                                        _( _.values( invalidSettingControls ) ).find( function( controls ) {
+                                                return _( controls ).find( function( control ) {
+                                                        var isExpanded = control.section() && api.section.has( control.section() ) && api.section( control.section() ).expanded();
+                                                        if ( isExpanded && control.expanded ) {
+                                                                isExpanded = control.expanded();
                                                         }
+                                                        if ( isExpanded ) {
+                                                                control.focus();
+                                                                wasFocused = true;
+                                                        }
+                                                        return wasFocused;
                                                 } );
                                         } );
-                                } );
 
-                                // Focus on the first control that is inside of an expanded section (one that is visible).
-                                _( invalidControls ).find( function( control ) {
-                                        var isExpanded = control.section() && api.section.has( control.section() ) && api.section( control.section() ).expanded();
-                                        if ( isExpanded && control.expanded ) {
-                                                isExpanded = control.expanded();
-                                        }
-                                        if ( isExpanded ) {
-                                                control.focus();
-                                                wasFocused = true;
+                                        // Focus on the first invalid control.
+                                        if ( ! wasFocused && ! _.isEmpty( invalidSettingControls ) ) {
+                                                _.values( invalidSettingControls )[0][0].focus();
                                         }
-                                        return wasFocused;
-                                } );
-
-                                // Focus on the first invalid control.
-                                if ( ! wasFocused && invalidControls[0] ) {
-                                        invalidControls[0].focus();
                                 }
                         },
 
@@ -3491 +3521 @@
                                         processing = api.state( 'processing' ),
                                         submitWhenDoneProcessing,
                                         submit,
-                                        modifiedWhileSaving = {};
+                                        modifiedWhileSaving = {},
+                                        invalidSettings = [],
+                                        invalidControls;
 
                                 body.addClass( 'saving' );
 
@@ -3502 +3534 @@
 
                                 submit = function () {
                                         var request, query;
+
+                                        /*
+                                         * Block saving if there are any settings that are marked as
+                                         * invalid from the client (not from the server). Focus on
+                                         * the control.
+                                         */
+                                        api.each( function( setting ) {
+                                                setting.notifications.each( function( notification ) {
+                                                        if ( 'error' === notification.type && ( ! notification.data || ! notification.data.from_server ) ) {
+                                                                invalidSettings.push( setting.id );
+                                                        }
+                                                } );
+                                        } );
+                                        invalidControls = api.findControlsForSettings( invalidSettings );
+                                        if ( ! _.isEmpty( invalidControls ) ) {
+                                                _.values( invalidControls )[0][0].focus();
+                                                body.removeClass( 'saving' );
+                                                api.unbind( 'change', captureSettingModifiedDuringSave );
+                                                return;
+                                        }
+
                                         query = $.extend( self.query(), {
                                                 nonce:  self.nonce.save
                                         } );
@@ -3512 +3565 @@
 
                                         api.trigger( 'save', request );
 
-                                        /*
-                                         * Remove all setting error notifications prior to save, allowing
-                                         * server to respond with fresh validation error notifications.
-                                         */
-                                        api.each( function( setting ) {
-                                                setting.notifications.each( function( notification ) {
-                                                        if ( 'error' === notification.type ) {
-                                                                setting.notifications.remove( notification.code );
-                                                        }
-                                                } );
-                                        } );
-
                                         request.always( function () {
                                                 body.removeClass( 'saving' );
                                                 saveBtn.prop( 'disabled', false );
@@ -3548 +3589 @@
                                                         } );
                                                 }
 
-                                                self._handleInvalidSettingsError( response );
+                                                if ( response.setting_validities ) {
+                                                        self._handleSettingValidities( {
+                                                                settingValidities: response.setting_validities,
+                                                                focusInvalidControl: true
+                                                        } );
+                                                }
 
                                                 api.trigger( 'error', response );
                                         } );
@@ -3564 +3610 @@
 
                                                 api.previewer.send( 'saved', response );
 
+                                                if ( response.setting_validities ) {
+                                                        self._handleSettingValidities( {
+                                                                settingValidities: response.setting_validities,
+                                                                focusInvalidControl: true
+                                                        } );
+                                                }
+
                                                 api.trigger( 'saved', response );
 
                                                 // Restore the global dirty state if any settings were modified during save.
@@ -3670 +3723 @@
                 });
 
                 /**
+                 * Find all controls associated with the given settings.
+                 *
+                 * @since 4.6.0
+                 * @param {string[]} settingIds Setting IDs.
+                 * @returns {object<string, wp.customize.Control>} Mapping setting ids to arrays of controls.
+                 */
+                api.findControlsForSettings = function findControlsForSettings( settingIds ) {
+                        var controls = {};
+                        _.each( _.unique( settingIds ), function( settingId ) {
+                                api.control.each( function( control ) {
+                                        _.each( control.settings, function( controlSetting ) {
+                                                if ( controlSetting.id === settingId ) {
+                                                        if ( ! controls[ settingId ] ) {
+                                                                controls[ settingId ] = [];
+                                                        }
+                                                        controls[ settingId ].push( control );
+                                                }
+                                        } );
+                                } );
+                        } );
+                        return controls;
+                },
+
+                /**
                  * Sort panels, sections, controls by priorities. Hide empty sections and panels.
                  *
                  * @since 4.1.0

src/wp-includes/class-wp-customize-manager.php

@@ -991 +991 @@
          * @since 4.6.0
          * @access public
          * @see WP_REST_Request::has_valid_params()
+         * @see WP_Customize_Setting::validate()
          *
          * @param array $setting_values Mapping of setting IDs to values to sanitize and validate.
-         * @return array Empty array if all settings were valid. One or more instances of `WP_Error` if any were invalid.
+         * @return array Mapping of setting IDs to return value of validate method calls, either `true` or `WP_Error`.
          */
         public function validate_setting_values( $setting_values ) {
                 $validity_errors = array();
@@ -1006 +1007 @@
                         if ( false === $validity || null === $validity ) {
                                 $validity = new WP_Error( 'invalid_value', __( 'Invalid value.' ) );
                         }
-                        if ( is_wp_error( $validity ) ) {
-                                $validity_errors[ $setting_id ] = $validity;
-                        }
+                        $validity_errors[ $setting_id ] = $validity;
                 }
                 return $validity_errors;
         }
@@ -1041 +1040 @@
                 do_action( 'customize_save_validation_before', $this );
 
                 // Validate settings.
-                $validity_errors = $this->validate_setting_values( $this->unsanitized_post_values() );
-                $invalid_count = count( $validity_errors );
-                if ( $invalid_count > 0 ) {
-                        $settings_errors = array();
-                        foreach ( $validity_errors as $setting_id => $validity_error ) {
-                                $settings_errors[ $setting_id ] = array();
-                                foreach ( $validity_error->errors as $error_code => $error_messages ) {
-                                        $settings_errors[ $setting_id ][ $error_code ] = array(
+                $setting_validities = $this->validate_setting_values( $this->unsanitized_post_values() );
+                $invalid_setting_count = 0;
+                $exported_setting_validities = array();
+                foreach ( $setting_validities as $setting_id => $validity ) {
+                        if ( is_wp_error( $validity ) ) {
+                                $invalid_setting_count += 1;
+                                $exported_setting_validities[ $setting_id ] = array();
+                                foreach ( $validity->errors as $error_code => $error_messages ) {
+                                        $error_data = $validity->get_error_data( $error_code );
+                                        if ( is_null( $error_data ) ) {
+                                                $error_data = array();
+                                        }
+                                        $error_data = array_merge(
+                                                $error_data,
+                                                array(
+                                                        'from_server' => true,
+                                                )
+                                        );
+                                        $exported_setting_validities[ $setting_id ][ $error_code ] = array(
                                                 'message' => join( ' ', $error_messages ),
-                                                'data' => $validity_error->get_error_data( $error_code ),
+                                                'data' => $error_data,
                                         );
                                 }
+                        } else {
+                                $exported_setting_validities[ $setting_id ] = true;
                         }
+                }
+                if ( $invalid_setting_count > 0 ) {
                         $response = array(
-                                'invalid_settings' => $settings_errors,
-                                'message' => sprintf( _n( 'There is %s invalid setting.', 'There are %s invalid settings.', $invalid_count ), number_format_i18n( $invalid_count ) ),
+                                'setting_validities' => $exported_setting_validities,
+                                'message' => sprintf( _n( 'There is %s invalid setting.', 'There are %s invalid settings.', $invalid_setting_count ), number_format_i18n( $invalid_setting_count ) ),
                         );
 
                         /** This filter is documented in wp-includes/class-wp-customize-manager.php */
@@ -1097 +1111 @@
                  */
                 do_action( 'customize_save_after', $this );
 
+                $data = array(
+                        'setting_validities' => $exported_setting_validities,
+                );
+
                 /**
                  * Filters response data for a successful customize_save AJAX request.
                  *
@@ -1108 +1126 @@
                  *                                   event on `wp.customize`.
                  * @param WP_Customize_Manager $this WP_Customize_Manager instance.
                  */
-                $response = apply_filters( 'customize_save_response', array(), $this );
+                $response = apply_filters( 'customize_save_response', $data, $this );
                 wp_send_json_success( $response );
         }
 

src/wp-includes/customize/class-wp-customize-selective-refresh.php

@@ -402 +402 @@
                         $response['errors'] = $this->triggered_errors;
                 }
 
+                $response['setting_validities'] = $this->manager->validate_setting_values( $this->manager->unsanitized_post_values() );
+
                 /**
                  * Filters the response from rendering the partials.
                  *