| /base/000_base/node_modules/jquery/src/event/focusin.js |
|---|
| @@ -0,0 +1,55 @@ |
|---|
| define( [ |
| "../core", |
| "../data/var/dataPriv", |
| "./support", |
| |
| "../event", |
| "./trigger" |
| ], function( jQuery, dataPriv, support ) { |
| |
| "use strict"; |
| |
| // Support: Firefox <=44 |
| // Firefox doesn't have focus(in | out) events |
| // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 |
| // |
| // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 |
| // focus(in | out) events fire after focus & blur events, |
| // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order |
| // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 |
| if ( !support.focusin ) { |
| jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { |
| |
| // Attach a single capturing handler on the document while someone wants focusin/focusout |
| var handler = function( event ) { |
| jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); |
| }; |
| |
| jQuery.event.special[ fix ] = { |
| setup: function() { |
| var doc = this.ownerDocument || this, |
| attaches = dataPriv.access( doc, fix ); |
| |
| if ( !attaches ) { |
| doc.addEventListener( orig, handler, true ); |
| } |
| dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); |
| }, |
| teardown: function() { |
| var doc = this.ownerDocument || this, |
| attaches = dataPriv.access( doc, fix ) - 1; |
| |
| if ( !attaches ) { |
| doc.removeEventListener( orig, handler, true ); |
| dataPriv.remove( doc, fix ); |
| |
| } else { |
| dataPriv.access( doc, fix, attaches ); |
| } |
| } |
| }; |
| } ); |
| } |
| |
| return jQuery; |
| } ); |
| /base/000_base/node_modules/jquery/src/event/trigger.js |
|---|
| @@ -0,0 +1,185 @@ |
|---|
| define( [ |
| "../core", |
| "../var/document", |
| "../data/var/dataPriv", |
| "../data/var/acceptData", |
| "../var/hasOwn", |
| |
| "../event" |
| ], function( jQuery, document, dataPriv, acceptData, hasOwn ) { |
| |
| "use strict"; |
| |
| var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/; |
| |
| jQuery.extend( jQuery.event, { |
| |
| trigger: function( event, data, elem, onlyHandlers ) { |
| |
| var i, cur, tmp, bubbleType, ontype, handle, special, |
| eventPath = [ elem || document ], |
| type = hasOwn.call( event, "type" ) ? event.type : event, |
| namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; |
| |
| cur = tmp = elem = elem || document; |
| |
| // Don't do events on text and comment nodes |
| if ( elem.nodeType === 3 || elem.nodeType === 8 ) { |
| return; |
| } |
| |
| // focus/blur morphs to focusin/out; ensure we're not firing them right now |
| if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { |
| return; |
| } |
| |
| if ( type.indexOf( "." ) > -1 ) { |
| |
| // Namespaced trigger; create a regexp to match event type in handle() |
| namespaces = type.split( "." ); |
| type = namespaces.shift(); |
| namespaces.sort(); |
| } |
| ontype = type.indexOf( ":" ) < 0 && "on" + type; |
| |
| // Caller can pass in a jQuery.Event object, Object, or just an event type string |
| event = event[ jQuery.expando ] ? |
| event : |
| new jQuery.Event( type, typeof event === "object" && event ); |
| |
| // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) |
| event.isTrigger = onlyHandlers ? 2 : 3; |
| event.namespace = namespaces.join( "." ); |
| event.rnamespace = event.namespace ? |
| new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : |
| null; |
| |
| // Clean up the event in case it is being reused |
| event.result = undefined; |
| if ( !event.target ) { |
| event.target = elem; |
| } |
| |
| // Clone any incoming data and prepend the event, creating the handler arg list |
| data = data == null ? |
| [ event ] : |
| jQuery.makeArray( data, [ event ] ); |
| |
| // Allow special events to draw outside the lines |
| special = jQuery.event.special[ type ] || {}; |
| if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { |
| return; |
| } |
| |
| // Determine event propagation path in advance, per W3C events spec (#9951) |
| // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) |
| if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { |
| |
| bubbleType = special.delegateType || type; |
| if ( !rfocusMorph.test( bubbleType + type ) ) { |
| cur = cur.parentNode; |
| } |
| for ( ; cur; cur = cur.parentNode ) { |
| eventPath.push( cur ); |
| tmp = cur; |
| } |
| |
| // Only add window if we got to document (e.g., not plain obj or detached DOM) |
| if ( tmp === ( elem.ownerDocument || document ) ) { |
| eventPath.push( tmp.defaultView || tmp.parentWindow || window ); |
| } |
| } |
| |
| // Fire handlers on the event path |
| i = 0; |
| while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { |
| |
| event.type = i > 1 ? |
| bubbleType : |
| special.bindType || type; |
| |
| // jQuery handler |
| handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && |
| dataPriv.get( cur, "handle" ); |
| if ( handle ) { |
| handle.apply( cur, data ); |
| } |
| |
| // Native handler |
| handle = ontype && cur[ ontype ]; |
| if ( handle && handle.apply && acceptData( cur ) ) { |
| event.result = handle.apply( cur, data ); |
| if ( event.result === false ) { |
| event.preventDefault(); |
| } |
| } |
| } |
| event.type = type; |
| |
| // If nobody prevented the default action, do it now |
| if ( !onlyHandlers && !event.isDefaultPrevented() ) { |
| |
| if ( ( !special._default || |
| special._default.apply( eventPath.pop(), data ) === false ) && |
| acceptData( elem ) ) { |
| |
| // Call a native DOM method on the target with the same name as the event. |
| // Don't do default actions on window, that's where global variables be (#6170) |
| if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) { |
| |
| // Don't re-trigger an onFOO event when we call its FOO() method |
| tmp = elem[ ontype ]; |
| |
| if ( tmp ) { |
| elem[ ontype ] = null; |
| } |
| |
| // Prevent re-triggering of the same event, since we already bubbled it above |
| jQuery.event.triggered = type; |
| elem[ type ](); |
| jQuery.event.triggered = undefined; |
| |
| if ( tmp ) { |
| elem[ ontype ] = tmp; |
| } |
| } |
| } |
| } |
| |
| return event.result; |
| }, |
| |
| // Piggyback on a donor event to simulate a different one |
| // Used only for `focus(in | out)` events |
| simulate: function( type, elem, event ) { |
| var e = jQuery.extend( |
| new jQuery.Event(), |
| event, |
| { |
| type: type, |
| isSimulated: true |
| } |
| ); |
| |
| jQuery.event.trigger( e, null, elem ); |
| } |
| |
| } ); |
| |
| jQuery.fn.extend( { |
| |
| trigger: function( type, data ) { |
| return this.each( function() { |
| jQuery.event.trigger( type, data, this ); |
| } ); |
| }, |
| triggerHandler: function( type, data ) { |
| var elem = this[ 0 ]; |
| if ( elem ) { |
| return jQuery.event.trigger( type, data, elem, true ); |
| } |
| } |
| } ); |
| |
| return jQuery; |
| } ); |
