WordPress.org

Make WordPress Core

Ticket #23367: 23367.refresh3.diff

File 23367.refresh3.diff, 6.0 KB (added by morganestes, 7 years ago)

Refresh with formatting changes suggested by @drewapicture

  • src/wp-admin/admin.php

    diff --git src/wp-admin/admin.php src/wp-admin/admin.php
    index 1040995..07bd801 100644
    set_screen_options(); 
    8888$date_format = get_option('date_format');
    8989$time_format = get_option('time_format');
    9090
     91wp_enqueue_script( 'wp-util' );
     92
     93$removable_url_params = array(
     94        'message', 'updated', 'settings-updated', 'saved',
     95        'activated', 'activate', 'deactivate', 'locked',
     96        'skipped', 'deleted', 'trashed', 'untrashed',
     97);
     98
     99/**
     100 * Filter the list of URL parameters to dynamically remove.
     101 *
     102 * @since 4.2.0
     103 *   
     104 * @param array $removable_url_params An array of parameters to remove from the URL.
     105 */
     106$removable_url_params = apply_filters( 'removable_url_params', $removable_url_params );
     107wp_localize_script( 'common', 'removableQueryArgs', $removable_url_params );
    91108wp_enqueue_script( 'common' );
    92109
    93110// $pagenow is set in vars.php
  • src/wp-admin/js/common.js

    diff --git src/wp-admin/js/common.js src/wp-admin/js/common.js
    index bcdb576..0cd188d 100644
    $(document).ready( function() { 
    838838                }
    839839        };
    840840
     841        /**
     842         * Remove parameters from admin pages after they're loaded so they don't trigger
     843         * messages again if the page is refreshed.
     844         *
     845         * This relies on history.replaceState, so is not available to IE < 10 without a polyfill.
     846         *
     847         * @link https://core.trac.wordpress.org/ticket/23367
     848         * @link http://caniuse.com/#search=pushstate
     849         *
     850         * @since 4.2.0
     851         */
     852        function removeQueryArgsFromUrl() {
     853                /**
     854                 * The list of parameters to check against.
     855                 *
     856                 * @type {Array}
     857                 */
     858                var removableQueryArgs = window.removableQueryArgs || [],
     859                        url;
     860
     861                // Create the wpUrlParams object.   
     862                wp.url.parseQueryArgs();
     863
     864                /**
     865                 * The filtered URL.
     866                 *
     867                 * @type {string}
     868                 */
     869                url = wp.url.removeQueryParam( removableQueryArgs );
     870
     871                if ( typeof history.replaceState === 'function' ) {
     872                        history.replaceState( null, null, url );
     873                }
     874        }
     875
    841876        window.wpResponsive.init();
    842877        setPinMenu();
     878        removeQueryArgsFromUrl();
    843879
    844880        $document.on( 'wp-window-resized.pin-menu postboxes-columnchange.pin-menu postbox-toggled.pin-menu wp-collapse-menu.pin-menu wp-scroll-start.pin-menu', setPinMenu );
    845881});
  • src/wp-includes/js/wp-util.js

    diff --git src/wp-includes/js/wp-util.js src/wp-includes/js/wp-util.js
    index 1985b35..7ef7b01 100644
    window.wp = window.wp || {}; 
    109109                }
    110110        };
    111111
     112        /**
     113         * Tools for retrieving and manipulating URLs.
     114         *
     115         * @since 4.2.0
     116         * @namespace
     117         */
     118        wp.url = {
     119                /**
     120                 * Remove a parameter from a URL query string.
     121                 *
     122                 * To avoid certain messages from being displayed more than once (like when a
     123                 * page is refreshed and a message is displayed based on the `msg=nnn` param),
     124                 * you can use this to strip out a whitelisted array of parameters.
     125                 *
     126                 * @since 4.2.0
     127                 *
     128                 * @param {Array}  [removableQueryArgs] Optional. The parameter names to remove.
     129                 * @param {String} [sourceURL]          Optional. The URL to parse; defaults to current URL.
     130                 * @returns {String} The URL with the filtered parameters.
     131                 */
     132                removeQueryParam: function ( /* removableQueryArgs, sourceURL */ ) {
     133                        /**
     134                         * The list of parameters to remove.
     135                         *
     136                         * @type {Array}
     137                         */
     138                        var removableQueryArgs = arguments[0] || window.removableQueryArgs,
     139                        /**
     140                         * The URL to parse.
     141                         *
     142                         * @type {String|Window.location.href}
     143                         */
     144                                sourceURL = arguments[1] || window.location.href,
     145                        /**
     146                         * The base URL.
     147                         *
     148                         * @type {string}
     149                         */
     150                                rtn = sourceURL.split( '?' )[0],
     151                        /**
     152                         * The query string of the URL (param=val).
     153                         *
     154                         * @type {string}
     155                         */
     156                            queryString = ( - 1 !== sourceURL.indexOf( '?' ) ) ? sourceURL.split( '?' )[1] : '',
     157                        /**
     158                         * A map of the query string.
     159                         *
     160                         * @type {Object}
     161                         */
     162                            params = window.wpUrlParams || wp.url.parseQueryArgs( sourceURL ),
     163                        /**
     164                         * The filtered parameters in an array of strings.
     165                         *
     166                         * @type {string[]}
     167                         */
     168                            newParams = [];
     169
     170                        if ( '' !== queryString ) {
     171                                _.reject( params, function( param, index ) {
     172                                        if( ! _.contains( removableQueryArgs, index ) ) {
     173                                                newParams.push( index + '=' + param );
     174                                        }
     175                                });
     176                        }
     177                       
     178                        return rtn + '?' + newParams.join( '&' );
     179                },
     180
     181                /**
     182                 * Parse the query string from a URL into an object of param:value.
     183                 *
     184                 * @since 4.2.0
     185                 *
     186                 * @param {String} [url] Optional. Defaults to current URL if not set.
     187                 * @returns {Object} The extracted parameters.
     188                 */
     189                parseQueryArgs: function ( /* url */ ) {
     190                        /**
     191                         * The URL to parse.
     192                         *
     193                         * @type {*|Window.location.href}
     194                         */
     195                        var url = arguments[0] || window.location.href,
     196                        /**
     197                         * The URL query string.
     198                         *
     199                         * @type {string}
     200                         */
     201                            queryString = ( - 1 !== url.indexOf( '?' ) ) ? url.split( '?' )[1] : '',
     202                        /**
     203                         * A collection of parameters and their values as strings.
     204                         *
     205                         * @type {Array}
     206                         */
     207                            params = [],
     208                        /**
     209                         * A collection of parameters and their values.
     210                         *
     211                         * @type {Object.<string, string>}
     212                         */
     213                            argMap = {},
     214                        /**
     215                         * The filtered {@link argMap}.
     216                         *
     217                         * @type {Object.<string, string>}
     218                         */
     219                            filteredArgMap = {};
     220
     221                        if ( '' !== queryString ) {
     222                                params = queryString.split( '&' );
     223                                _.each( params, function ( param ) {
     224                                        /**
     225                                         * An array containing the the param[0] and value[1].
     226                                         *
     227                                         * @type {Array}
     228                                         */
     229                                        var p = param.split( '=' );
     230                                        argMap[ p[0] ] = p[1];
     231                                } );
     232                        }
     233                       
     234                        // Filter the object so it only contains our declared values,
     235                        // and not inherited ones from the Object prototype.
     236                        for ( var arg in argMap ) {
     237                                if ( argMap.hasOwnProperty( arg ) ) {
     238                                        filteredArgMap[arg] = argMap[arg];
     239                                }
     240                        }
     241                       
     242                        /**
     243                         * Make the params available to the DOM.
     244                         *
     245                         * @global
     246                         * @type {Object.<string, string>}
     247                         */
     248                        return window.wpUrlParams = filteredArgMap;
     249                }
     250        };
    112251}(jQuery));