JAVASCRIPT   16

trigger.js

Guest on 24th May 2021 03:51:23 AM

  1. define( [
  2.       "../core",
  3.       "../var/document",
  4.       "../data/var/dataPriv",
  5.       "../data/var/acceptData",
  6.       "../var/hasOwn",
  7.  
  8.       "../event"
  9. ], function( jQuery, document, dataPriv, acceptData, hasOwn ) {
  10.  
  11. "use strict";
  12.  
  13. var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
  14.  
  15. jQuery.extend( jQuery.event, {
  16.  
  17.       trigger: function( event, data, elem, onlyHandlers ) {
  18.  
  19.             var i, cur, tmp, bubbleType, ontype, handle, special,
  20.                   eventPath = [ elem || document ],
  21.                   type = hasOwn.call( event, "type" ) ? event.type : event,
  22.                   namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
  23.  
  24.             cur = tmp = elem = elem || document;
  25.  
  26.             // Don't do events on text and comment nodes
  27.             if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
  28.                   return;
  29.             }
  30.  
  31.             // focus/blur morphs to focusin/out; ensure we're not firing them right now
  32.             if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
  33.                   return;
  34.             }
  35.  
  36.             if ( type.indexOf( "." ) > -1 ) {
  37.  
  38.                   // Namespaced trigger; create a regexp to match event type in handle()
  39.                   namespaces = type.split( "." );
  40.                   type = namespaces.shift();
  41.                   namespaces.sort();
  42.             }
  43.             ontype = type.indexOf( ":" ) < 0 && "on" + type;
  44.  
  45.             // Caller can pass in a jQuery.Event object, Object, or just an event type string
  46.             event = event[ jQuery.expando ] ?
  47.                   event :
  48.                   new jQuery.Event( type, typeof event === "object" && event );
  49.  
  50.             // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
  51.             event.isTrigger = onlyHandlers ? 2 : 3;
  52.             event.namespace = namespaces.join( "." );
  53.             event.rnamespace = event.namespace ?
  54.                   new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
  55.                   null;
  56.  
  57.             // Clean up the event in case it is being reused
  58.             event.result = undefined;
  59.             if ( !event.target ) {
  60.                   event.target = elem;
  61.             }
  62.  
  63.             // Clone any incoming data and prepend the event, creating the handler arg list
  64.             data = data == null ?
  65.                   [ event ] :
  66.                   jQuery.makeArray( data, [ event ] );
  67.  
  68.             // Allow special events to draw outside the lines
  69.             special = jQuery.event.special[ type ] || {};
  70.             if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
  71.                   return;
  72.             }
  73.  
  74.             // Determine event propagation path in advance, per W3C events spec (#9951)
  75.             // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
  76.             if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
  77.  
  78.                   bubbleType = special.delegateType || type;
  79.                   if ( !rfocusMorph.test( bubbleType + type ) ) {
  80.                         cur = cur.parentNode;
  81.                   }
  82.                   for ( ; cur; cur = cur.parentNode ) {
  83.                         eventPath.push( cur );
  84.                         tmp = cur;
  85.                   }
  86.  
  87.                   // Only add window if we got to document (e.g., not plain obj or detached DOM)
  88.                   if ( tmp === ( elem.ownerDocument || document ) ) {
  89.                         eventPath.push( tmp.defaultView || tmp.parentWindow || window );
  90.                   }
  91.             }
  92.  
  93.             // Fire handlers on the event path
  94.             i = 0;
  95.             while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
  96.  
  97.                   event.type = i > 1 ?
  98.                         bubbleType :
  99.                         special.bindType || type;
  100.  
  101.                   // jQuery handler
  102.                   handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
  103.                         dataPriv.get( cur, "handle" );
  104.                   if ( handle ) {
  105.                         handle.apply( cur, data );
  106.                   }
  107.  
  108.                   // Native handler
  109.                   handle = ontype && cur[ ontype ];
  110.                   if ( handle && handle.apply && acceptData( cur ) ) {
  111.                         event.result = handle.apply( cur, data );
  112.                         if ( event.result === false ) {
  113.                               event.preventDefault();
  114.                         }
  115.                   }
  116.             }
  117.             event.type = type;
  118.  
  119.             // If nobody prevented the default action, do it now
  120.             if ( !onlyHandlers && !event.isDefaultPrevented() ) {
  121.  
  122.                   if ( ( !special._default ||
  123.                         special._default.apply( eventPath.pop(), data ) === false ) &&
  124.                         acceptData( elem ) ) {
  125.  
  126.                         // Call a native DOM method on the target with the same name as the event.
  127.                         // Don't do default actions on window, that's where global variables be (#6170)
  128.                         if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
  129.  
  130.                               // Don't re-trigger an onFOO event when we call its FOO() method
  131.                               tmp = elem[ ontype ];
  132.  
  133.                               if ( tmp ) {
  134.                                     elem[ ontype ] = null;
  135.                               }
  136.  
  137.                               // Prevent re-triggering of the same event, since we already bubbled it above
  138.                               jQuery.event.triggered = type;
  139.                               elem[ type ]();
  140.                               jQuery.event.triggered = undefined;
  141.  
  142.                               if ( tmp ) {
  143.                                     elem[ ontype ] = tmp;
  144.                               }
  145.                         }
  146.                   }
  147.             }
  148.  
  149.             return event.result;
  150.       },
  151.  
  152.       // Piggyback on a donor event to simulate a different one
  153.       // Used only for `focus(in | out)` events
  154.       simulate: function( type, elem, event ) {
  155.             var e = jQuery.extend(
  156.                   new jQuery.Event(),
  157.                   event,
  158.                   {
  159.                         type: type,
  160.                         isSimulated: true
  161.                   }
  162.             );
  163.  
  164.             jQuery.event.trigger( e, null, elem );
  165.       }
  166.  
  167. } );
  168.  
  169. jQuery.fn.extend( {
  170.  
  171.       trigger: function( type, data ) {
  172.             return this.each( function() {
  173.                   jQuery.event.trigger( type, data, this );
  174.             } );
  175.       },
  176.       triggerHandler: function( type, data ) {
  177.             var elem = this[ 0 ];
  178.             if ( elem ) {
  179.                   return jQuery.event.trigger( type, data, elem, true );
  180.             }
  181.       }
  182. } );
  183.  
  184. return jQuery;
  185. } );

Raw Paste


Login or Register to edit or fork this paste. It's free.