WordPress.org

Make WordPress Core

Ticket #33300: 33300.6.patch

File 33300.6.patch, 5.5 KB (added by azaozz, 5 years ago)
  • src/wp-includes/js/tinymce/plugins/wptextpattern/plugin.js

     
    1616        }
    1717
    1818        tinymce.PluginManager.add( 'wptextpattern', function( editor ) {
    19                 var VK = tinymce.util.VK;
     19                var VK = tinymce.util.VK,
     20                        settings = editor.settings,
     21                        extend = tinymce.extend,
     22                        each = tinymce.each,
     23                        chars = [],
     24                        canUndo;
    2025
    21                 var spacePatterns = [
    22                         { regExp: /^[*-]\s/, cmd: 'InsertUnorderedList' },
    23                         { regExp: /^1[.)]\s/, cmd: 'InsertOrderedList' }
    24                 ];
     26                /**
     27                 * Setting for the patterns can be added or replaced by using the
     28                 * 'tiny_mce_before_init' filter (from PHP).
     29                 *
     30                 * The editor options are: wptextpattern_space_patterns,
     31                 * wptextpattern_enter_patterns, and wptextpattern_inline_patterns.
     32                 * The format is same as below: an object of objects containing the pattrern settings.
     33                 *
     34                 * Note: the keys in the settings objects are not signigicant. They can be used
     35                 * to override the default settings if needed.
     36                 *
     37                 * Example:
     38                 *     add_filter( 'tiny_mce_before_init', 'textpatterns_test' );
     39                 *     function textpatterns_test( $init ) {
     40                 *         $init['wptextpattern_inline_patterns'] = '{
     41                 *             strong: { start: "*", end: "*", format: "bold" },
     42                 *             strong2: { start: "**", end: "**", format: "bold" },
     43                 *             em: { start: "_", end: "_", format: "italic" }
     44                 *         }';
     45                 *
     46                 *         return $init;
     47                 *     }
     48                 */
     49                var spacePatterns = extend( {
     50                                ul: { regExp: /^[*-]\s/, cmd: 'InsertUnorderedList' },
     51                                ol: { regExp: /^1[.)]\s/, cmd: 'InsertOrderedList' }
     52                        },
     53                        settings.wptextpattern_space_patterns || {}
     54                );
    2555
    26                 var enterPatterns = [
    27                         { start: '##', format: 'h2' },
    28                         { start: '###', format: 'h3' },
    29                         { start: '####', format: 'h4' },
    30                         { start: '#####', format: 'h5' },
    31                         { start: '######', format: 'h6' },
    32                         { start: '>', format: 'blockquote' },
    33                         { regExp: /^(-){3,}$/, element: 'hr' }
    34                 ];
     56                var enterPatterns = extend( {
     57                                h2:         { start: '##', format: 'h2' },
     58                                h3:         { start: '###', format: 'h3' },
     59                                h4:         { start: '####', format: 'h4' },
     60                                h5:         { start: '#####', format: 'h5' },
     61                                h6:         { start: '######', format: 'h6' },
     62                                blockquote: { start: '>', format: 'blockquote' },
     63                                hr:         { regExp: /^(-){3,}$/, element: 'hr' }
     64                        },
     65                        settings.wptextpattern_enter_patterns || {}
     66                );
    3567
    36                 var inlinePatterns = [
    37                         { start: '`', end: '`', format: 'code' }
    38                 ];
     68                var inlinePatterns = extend( {
     69                                code: { start: '`', end: '`', format: 'code' }
     70                        },
     71                        settings.wptextpattern_inline_patterns || {}
     72                );
    3973
    40                 var canUndo;
    41                 var chars = [];
     74                // Convert to array and sort descending by start length.
     75                function toSortedArray( patterns ) {
     76                        patterns = tinymce.map( patterns, function( pattern ) {
     77                                return pattern;
     78                        } );
    4279
    43                 tinymce.each( inlinePatterns, function( pattern ) {
    44                         tinymce.each( ( pattern.start + pattern.end ).split( '' ), function( c ) {
     80                        patterns.sort( function( a, b ) {
     81                                if ( a.start && b.start ) {
     82                                        if ( a.start.length > b.start.length ) {
     83                                                return -1;
     84                                        }
     85
     86                                        if ( a.start.length < b.start.length ) {
     87                                                return 1;
     88                                        }
     89                                }
     90
     91                                return 0;
     92                        });
     93
     94                        return patterns;
     95                }
     96
     97                spacePatterns = toSortedArray( spacePatterns );
     98                enterPatterns = toSortedArray( enterPatterns );
     99                inlinePatterns = toSortedArray( inlinePatterns );
     100
     101                each( inlinePatterns, function( pattern ) {
     102                        each( ( pattern.start + pattern.end ).split( '' ), function( c ) {
    45103                                if ( tinymce.inArray( chars, c ) === -1 ) {
    46104                                        chars.push( c );
    47105                                }
     
    91149                        }
    92150
    93151                        function findStart( node ) {
    94                                 var i = inlinePatterns.length;
    95152                                var offset;
    96153
    97                                 while ( i-- ) {
    98                                         pattern = inlinePatterns[ i ];
     154                                each( inlinePatterns, function( currentPattern ) {
     155                                        pattern = currentPattern;
    99156                                        offset = node.data.indexOf( pattern.end );
    100157
    101158                                        if ( offset !== -1 ) {
    102                                                 return offset;
     159                                                return false;
    103160                                        }
    104                                 }
     161                                } );
     162
     163                                return offset;
    105164                        }
    106165
    107166                        startOffset = findStart( node );
     
    201260                        parent = node.parentNode;
    202261                        text = node.data;
    203262
    204                         tinymce.each( spacePatterns, function( pattern ) {
     263                        each( spacePatterns, function( pattern ) {
    205264                                var match = text.match( pattern.regExp );
    206265
    207266                                if ( ! match || rng.startOffset !== match[0].length ) {
     
    234293                        var rng = editor.selection.getRng(),
    235294                                start = rng.startContainer,
    236295                                node = firstTextNode( start ),
    237                                 i = enterPatterns.length,
    238296                                text, pattern, parent;
    239297
    240298                        if ( ! node ) {
     
    243301
    244302                        text = node.data;
    245303
    246                         while ( i-- ) {
    247                                 if ( enterPatterns[ i ].start ) {
    248                                         if ( text.indexOf( enterPatterns[ i ].start ) === 0 ) {
    249                                                 pattern = enterPatterns[ i ];
    250                                                 break;
     304                        each( enterPatterns, function( currentPattern ) {
     305                                if ( currentPattern.start ) {
     306                                        if ( text.indexOf( currentPattern.start ) === 0 ) {
     307                                                pattern = currentPattern;
     308                                                return false;
    251309                                        }
    252                                 } else if ( enterPatterns[ i ].regExp ) {
    253                                         if ( enterPatterns[ i ].regExp.test( text ) ) {
    254                                                 pattern = enterPatterns[ i ];
    255                                                 break;
     310                                } else if ( currentPattern.regExp ) {
     311                                        if ( currentPattern.regExp.test( text ) ) {
     312                                                pattern = currentPattern;
     313                                                return false;
    256314                                        }
    257315                                }
    258                         }
     316                        } );
    259317
    260318                        if ( ! pattern ) {
    261319                                return;