WordPress.org

Make WordPress Core

Ticket #36459: 36459.patch

File 36459.patch, 3.3 KB (added by gitlost, 6 years ago)

Less strict keyCode checking plus other changes.

  • src/wp-includes/js/tinymce/plugins/wptextpattern/plugin.js

     
    4141                var chars = [];
    4242
    4343                tinymce.each( inlinePatterns, function( pattern ) {
    44                         tinymce.each( ( pattern.start + pattern.end ).split( '' ), function( c ) {
     44                        tinymce.each( ( pattern.end ).split( '' ), function( c ) {
    4545                                if ( tinymce.inArray( chars, c ) === -1 ) {
    4646                                        chars.push( c );
    4747                                }
     
    6565                }, true );
    6666
    6767                editor.on( 'keyup', function( event ) {
     68                        var did_space = false;
    6869                        if ( event.keyCode === VK.SPACEBAR && ! event.ctrlKey && ! event.metaKey && ! event.altKey ) {
    69                                 space();
    70                         } else if ( event.keyCode > 47 && ! ( event.keyCode >= 91 && event.keyCode <= 93 ) ) {
     70                                did_space = space();
     71                        }
     72                        if ( ! did_space && ! ( event.keyCode >= 1 && event.keyCode <= 31 ) && ! (event.keyCode >= 91 && event.keyCode <= 93 ) ) {
    7173                                inline();
    7274                        }
    7375                } );
     
    8789                        }
    8890
    8991                        if ( tinymce.inArray( chars, node.data.charAt( offset - 1 ) ) === -1 ) {
    90                                 return;
     92                                // Allow for one character of type ahead.
     93                                if ( --offset <= 1 || tinymce.inArray( chars, node.data.charAt( offset - 1 ) ) === -1 ) {
     94                                        return;
     95                                }
    9196                        }
    9297
    93                         function findStart( node ) {
     98                        function findEnd( node ) {
    9499                                var i = inlinePatterns.length;
    95                                 var offset;
     100                                var index;
    96101
    97102                                while ( i-- ) {
    98103                                        pattern = inlinePatterns[ i ];
    99                                         offset = node.data.indexOf( pattern.end );
     104                                        index = node.data.lastIndexOf( pattern.end );
    100105
    101                                         if ( offset !== -1 ) {
    102                                                 return offset;
     106                                        if ( index !== -1 && index === offset - pattern.end.length ) {
     107                                                return index;
    103108                                        }
    104109                                }
    105110                        }
    106111
    107                         startOffset = findStart( node );
    108                         endOffset = node.data.lastIndexOf( pattern.end );
    109 
    110                         if ( startOffset === endOffset || endOffset === -1 ) {
     112                        endOffset = findEnd( node );
     113                        if ( ! endOffset ) {
    111114                                return;
    112115                        }
     116                        startOffset = node.data.substr( 0, endOffset ).lastIndexOf( pattern.start );
     117                        if ( startOffset === -1 ) {
     118                                return;
     119                        }
    113120
    114121                        if ( endOffset - startOffset <= pattern.start.length ) {
    115122                                return;
    116123                        }
    117124
    118                         if ( node.data.slice( startOffset + pattern.start.length, endOffset ).indexOf( pattern.start.slice( 0, 1 ) ) !== -1 ) {
     125                        // Ignore if in pattern node already.
     126                        if ( node.parentNode.nodeName.toLowerCase() === pattern.format ) {
    119127                                return;
    120128                        }
    121129
     130                        // Ignore if a single white space or empty as node won't be created by editor.formatter.apply() below (same test as tinymce/Formatter/isWhiteSpaceNode()).
     131                        if ( /^([\t \r\n]+|)$/.test( node.data.slice( startOffset + pattern.start.length, endOffset ) ) ) {
     132                                return;
     133                        }
     134
    122135                        format = editor.formatter.get( pattern.format );
    123136
    124137                        if ( format && format[0].inline ) {
     
    192205                        var rng = editor.selection.getRng(),
    193206                                node = rng.startContainer,
    194207                                parent,
    195                                 text;
     208                                text,
     209                                ret = false;
    196210
    197211                        if ( ! node || firstTextNode( node ) !== node ) {
    198                                 return;
     212                                return ret;
    199213                        }
    200214
    201215                        parent = node.parentNode;
     
    225239                                setTimeout( function() {
    226240                                        canUndo = 'space';
    227241                                } );
     242                                ret = true;
    228243
    229244                                return false;
    230245                        } );
     246
     247                        return ret;
    231248                }
    232249
    233250                function enter() {