Ticket #40974: 40974.4.diff

src/wp-admin/js/widgets/text-widgets.js

@@ -164 +164 @@
                  * @returns {void}
                  */
                 initializeEditor: function initializeEditor() {
-                        var control = this, changeDebounceDelay = 1000, id, textarea, restoreTextMode = false;
+                        var control = this, changeDebounceDelay = 1000, id, textarea, triggerChangeIfDirty, restoreTextMode = false;
                         textarea = control.fields.text;
                         id = textarea.attr( 'id' );
 
                         /**
+                         * Trigger change if dirty.
+                         *
+                         * @param {jQuery.Event} [event] Related event.
+                         * @returns {void}
+                         */
+                        triggerChangeIfDirty = function( event ) {
+                                var updateWidgetBuffer = 300; // See wp.customize.Widgets.WidgetControl._setupUpdateUI() which uses 250ms for updateWidgetDebounced.
+                                if ( control.editor.isDirty() || ( event && 'paste' === event.type ) ) {
+
+                                        /*
+                                         * Account for race condition in customizer where user clicks Save & Publish while
+                                         * focus was just previously given to to the editor. Since updates to the editor
+                                         * are debounced at 1 second and since widget input changes are only synced to
+                                         * settings after 250ms, the customizer needs to be put into the processing
+                                         * state during the time between the change event is triggered and updateWidget
+                                         * logic starts. Note that the debounced update-widget request should be able
+                                         * to be removed with the removal of the update-widget request entirely once
+                                         * widgets are able to mutate their own instance props directly in JS without
+                                         * having to make server round-trips to call the respective WP_Widget::update()
+                                         * callbacks. See <https://core.trac.wordpress.org/ticket/33507>.
+                                         */
+                                        if ( wp.customize && wp.customize.state ) {
+                                                wp.customize.state( 'processing' ).set( wp.customize.state( 'processing' ).get() + 1 );
+                                                _.delay( function() {
+                                                        wp.customize.state( 'processing' ).set( wp.customize.state( 'processing' ).get() - 1 );
+                                                }, updateWidgetBuffer );
+                                        }
+
+                                        if ( ! control.editor.isHidden() ) {
+                                                control.editor.save();
+                                        }
+                                        textarea.trigger( 'change' );
+                                }
+                        };
+
+                        // Just-in-time force-update the hidden input fields.
+                        control.syncContainer.closest( '.widget' ).find( '[name=savewidget]:first' ).on( 'click', function onClickSaveButton() {
+                                triggerChangeIfDirty();
+                                control.syncContainer.find( 'input.title' ).val( control.fields.title.val() );
+                                control.syncContainer.find( 'input.text' ).val( control.fields.text.val() );
+                        });
+
+                        /**
                          * Build (or re-build) the visual editor.
                          *
                          * @returns {void}
                          */
                         function buildEditor() {
-                                var editor, triggerChangeIfDirty, onInit, showPointerElement;
+                                var editor, onInit, showPointerElement;
 
                                 // Abort building if the textarea is gone, likely due to the widget having been deleted entirely.
                                 if ( ! document.getElementById( id ) ) {
@@ -230 +273 @@
 
                                         // If a prior mce instance was replaced, and it was in text mode, toggle to text mode.
                                         if ( restoreTextMode ) {
-                                                switchEditors.go( id, 'toggle' );
+                                                switchEditors.go( id, 'html' );
                                         }
 
                                         // Show the pointer.
@@ -269 +312 @@
                                 }
 
                                 control.editorFocused = false;
-                                triggerChangeIfDirty = function() {
-                                        var updateWidgetBuffer = 300; // See wp.customize.Widgets.WidgetControl._setupUpdateUI() which uses 250ms for updateWidgetDebounced.
-                                        if ( editor.isDirty() ) {
-
-                                                /*
-                                                 * Account for race condition in customizer where user clicks Save & Publish while
-                                                 * focus was just previously given to to the editor. Since updates to the editor
-                                                 * are debounced at 1 second and since widget input changes are only synced to
-                                                 * settings after 250ms, the customizer needs to be put into the processing
-                                                 * state during the time between the change event is triggered and updateWidget
-                                                 * logic starts. Note that the debounced update-widget request should be able
-                                                 * to be removed with the removal of the update-widget request entirely once
-                                                 * widgets are able to mutate their own instance props directly in JS without
-                                                 * having to make server round-trips to call the respective WP_Widget::update()
-                                                 * callbacks. See <https://core.trac.wordpress.org/ticket/33507>.
-                                                 */
-                                                if ( wp.customize && wp.customize.state ) {
-                                                        wp.customize.state( 'processing' ).set( wp.customize.state( 'processing' ).get() + 1 );
-                                                        _.delay( function() {
-                                                                wp.customize.state( 'processing' ).set( wp.customize.state( 'processing' ).get() - 1 );
-                                                        }, updateWidgetBuffer );
-                                                }
 
-                                                editor.save();
-                                                textarea.trigger( 'change' );
-                                        }
-                                };
-                                editor.on( 'focus', function() {
+                                editor.on( 'focus', function onEditorFocus() {
                                         control.editorFocused = true;
                                 });
+                                editor.on( 'paste', function onEditorPaste( event ) {
+                                        triggerChangeIfDirty( event );
+                                });
                                 editor.on( 'NodeChange', _.debounce( triggerChangeIfDirty, changeDebounceDelay ) );
-                                editor.on( 'blur', function() {
+                                editor.on( 'blur hide', function onEditorBlur( event ) {
                                         control.editorFocused = false;
-                                        triggerChangeIfDirty();
+                                        triggerChangeIfDirty( event );
                                 });
 
                                 control.editor = editor;