POLICY-SDK-APP/src/main/webapp/app/policyApp/libs/bower_components/jquery/src/effects.js

   1 define([
   2         "./core",
   3         "./var/pnum",
   4         "./css/var/cssExpand",
   5         "./css/var/isHidden",
   6         "./css/defaultDisplay",
   7         "./data/var/data_priv",
   8
   9         "./core/init",
  10         "./effects/Tween",
  11         "./queue",
  12         "./css",
  13         "./deferred",
  14         "./traversing"
  15 ], function( jQuery, pnum, cssExpand, isHidden, defaultDisplay, data_priv ) {
  16
  17 var
  18         fxNow, timerId,
  19         rfxtypes = /^(?:toggle|show|hide)$/,
  20         rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
  21         rrun = /queueHooks$/,
  22         animationPrefilters = [ defaultPrefilter ],
  23         tweeners = {
  24                 "*": [ function( prop, value ) {
  25                         var tween = this.createTween( prop, value ),
  26                                 target = tween.cur(),
  27                                 parts = rfxnum.exec( value ),
  28                                 unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
  29
  30                                 // Starting value computation is required for potential unit mismatches
  31                                 start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) &&
  32                                         rfxnum.exec( jQuery.css( tween.elem, prop ) ),
  33                                 scale = 1,
  34                                 maxIterations = 20;
  35
  36                         if ( start && start[ 3 ] !== unit ) {
  37                                 // Trust units reported by jQuery.css
  38                                 unit = unit || start[ 3 ];
  39
  40                                 // Make sure we update the tween properties later on
  41                                 parts = parts || [];
  42
  43                                 // Iteratively approximate from a nonzero starting point
  44                                 start = +target || 1;
  45
  46                                 do {
  47                                         // If previous iteration zeroed out, double until we get *something*.
  48                                         // Use string for doubling so we don't accidentally see scale as unchanged below
  49                                         scale = scale || ".5";
  50
  51                                         // Adjust and apply
  52                                         start = start / scale;
  53                                         jQuery.style( tween.elem, prop, start + unit );
  54
  55                                 // Update scale, tolerating zero or NaN from tween.cur(),
  56                                 // break the loop if scale is unchanged or perfect, or if we've just had enough
  57                                 } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
  58                         }
  59
  60                         // Update tween properties
  61                         if ( parts ) {
  62                                 start = tween.start = +start || +target || 0;
  63                                 tween.unit = unit;
  64                                 // If a +=/-= token was provided, we're doing a relative animation
  65                                 tween.end = parts[ 1 ] ?
  66                                         start + ( parts[ 1 ] + 1 ) * parts[ 2 ] :
  67                                         +parts[ 2 ];
  68                         }
  69
  70                         return tween;
  71                 } ]
  72         };
  73
  74 // Animations created synchronously will run synchronously
  75 function createFxNow() {
  76         setTimeout(function() {
  77                 fxNow = undefined;
  78         });
  79         return ( fxNow = jQuery.now() );
  80 }
  81
  82 // Generate parameters to create a standard animation
  83 function genFx( type, includeWidth ) {
  84         var which,
  85                 i = 0,
  86                 attrs = { height: type };
  87
  88         // If we include width, step value is 1 to do all cssExpand values,
  89         // otherwise step value is 2 to skip over Left and Right
  90         includeWidth = includeWidth ? 1 : 0;
  91         for ( ; i < 4 ; i += 2 - includeWidth ) {
  92                 which = cssExpand[ i ];
  93                 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
  94         }
  95
  96         if ( includeWidth ) {
  97                 attrs.opacity = attrs.width = type;
  98         }
  99
 100         return attrs;
 101 }
 102
 103 function createTween( value, prop, animation ) {
 104         var tween,
 105                 collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
 106                 index = 0,
 107                 length = collection.length;
 108         for ( ; index < length; index++ ) {
 109                 if ( (tween = collection[ index ].call( animation, prop, value )) ) {
 110
 111                         // We're done with this property
 112                         return tween;
 113                 }
 114         }
 115 }
 116
 117 function defaultPrefilter( elem, props, opts ) {
 118         /* jshint validthis: true */
 119         var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
 120                 anim = this,
 121                 orig = {},
 122                 style = elem.style,
 123                 hidden = elem.nodeType && isHidden( elem ),
 124                 dataShow = data_priv.get( elem, "fxshow" );
 125
 126         // Handle queue: false promises
 127         if ( !opts.queue ) {
 128                 hooks = jQuery._queueHooks( elem, "fx" );
 129                 if ( hooks.unqueued == null ) {
 130                         hooks.unqueued = 0;
 131                         oldfire = hooks.empty.fire;
 132                         hooks.empty.fire = function() {
 133                                 if ( !hooks.unqueued ) {
 134                                         oldfire();
 135                                 }
 136                         };
 137                 }
 138                 hooks.unqueued++;
 139
 140                 anim.always(function() {
 141                         // Ensure the complete handler is called before this completes
 142                         anim.always(function() {
 143                                 hooks.unqueued--;
 144                                 if ( !jQuery.queue( elem, "fx" ).length ) {
 145                                         hooks.empty.fire();
 146                                 }
 147                         });
 148                 });
 149         }
 150
 151         // Height/width overflow pass
 152         if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
 153                 // Make sure that nothing sneaks out
 154                 // Record all 3 overflow attributes because IE9-10 do not
 155                 // change the overflow attribute when overflowX and
 156                 // overflowY are set to the same value
 157                 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
 158
 159                 // Set display property to inline-block for height/width
 160                 // animations on inline elements that are having width/height animated
 161                 display = jQuery.css( elem, "display" );
 162
 163                 // Test default display if display is currently "none"
 164                 checkDisplay = display === "none" ?
 165                         data_priv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
 166
 167                 if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
 168                         style.display = "inline-block";
 169                 }
 170         }
 171
 172         if ( opts.overflow ) {
 173                 style.overflow = "hidden";
 174                 anim.always(function() {
 175                         style.overflow = opts.overflow[ 0 ];
 176                         style.overflowX = opts.overflow[ 1 ];
 177                         style.overflowY = opts.overflow[ 2 ];
 178                 });
 179         }
 180
 181         // show/hide pass
 182         for ( prop in props ) {
 183                 value = props[ prop ];
 184                 if ( rfxtypes.exec( value ) ) {
 185                         delete props[ prop ];
 186                         toggle = toggle || value === "toggle";
 187                         if ( value === ( hidden ? "hide" : "show" ) ) {
 188
 189                                 // If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden
 190                                 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
 191                                         hidden = true;
 192                                 } else {
 193                                         continue;
 194                                 }
 195                         }
 196                         orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
 197
 198                 // Any non-fx value stops us from restoring the original display value
 199                 } else {
 200                         display = undefined;
 201                 }
 202         }
 203
 204         if ( !jQuery.isEmptyObject( orig ) ) {
 205                 if ( dataShow ) {
 206                         if ( "hidden" in dataShow ) {
 207                                 hidden = dataShow.hidden;
 208                         }
 209                 } else {
 210                         dataShow = data_priv.access( elem, "fxshow", {} );
 211                 }
 212
 213                 // Store state if its toggle - enables .stop().toggle() to "reverse"
 214                 if ( toggle ) {
 215                         dataShow.hidden = !hidden;
 216                 }
 217                 if ( hidden ) {
 218                         jQuery( elem ).show();
 219                 } else {
 220                         anim.done(function() {
 221                                 jQuery( elem ).hide();
 222                         });
 223                 }
 224                 anim.done(function() {
 225                         var prop;
 226
 227                         data_priv.remove( elem, "fxshow" );
 228                         for ( prop in orig ) {
 229                                 jQuery.style( elem, prop, orig[ prop ] );
 230                         }
 231                 });
 232                 for ( prop in orig ) {
 233                         tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
 234
 235                         if ( !( prop in dataShow ) ) {
 236                                 dataShow[ prop ] = tween.start;
 237                                 if ( hidden ) {
 238                                         tween.end = tween.start;
 239                                         tween.start = prop === "width" || prop === "height" ? 1 : 0;
 240                                 }
 241                         }
 242                 }
 243
 244         // If this is a noop like .hide().hide(), restore an overwritten display value
 245         } else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
 246                 style.display = display;
 247         }
 248 }
 249
 250 function propFilter( props, specialEasing ) {
 251         var index, name, easing, value, hooks;
 252
 253         // camelCase, specialEasing and expand cssHook pass
 254         for ( index in props ) {
 255                 name = jQuery.camelCase( index );
 256                 easing = specialEasing[ name ];
 257                 value = props[ index ];
 258                 if ( jQuery.isArray( value ) ) {
 259                         easing = value[ 1 ];
 260                         value = props[ index ] = value[ 0 ];
 261                 }
 262
 263                 if ( index !== name ) {
 264                         props[ name ] = value;
 265                         delete props[ index ];
 266                 }
 267
 268                 hooks = jQuery.cssHooks[ name ];
 269                 if ( hooks && "expand" in hooks ) {
 270                         value = hooks.expand( value );
 271                         delete props[ name ];
 272
 273                         // Not quite $.extend, this won't overwrite existing keys.
 274                         // Reusing 'index' because we have the correct "name"
 275                         for ( index in value ) {
 276                                 if ( !( index in props ) ) {
 277                                         props[ index ] = value[ index ];
 278                                         specialEasing[ index ] = easing;
 279                                 }
 280                         }
 281                 } else {
 282                         specialEasing[ name ] = easing;
 283                 }
 284         }
 285 }
 286
 287 function Animation( elem, properties, options ) {
 288         var result,
 289                 stopped,
 290                 index = 0,
 291                 length = animationPrefilters.length,
 292                 deferred = jQuery.Deferred().always( function() {
 293                         // Don't match elem in the :animated selector
 294                         delete tick.elem;
 295                 }),
 296                 tick = function() {
 297                         if ( stopped ) {
 298                                 return false;
 299                         }
 300                         var currentTime = fxNow || createFxNow(),
 301                                 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
 302                                 // Support: Android 2.3
 303                                 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
 304                                 temp = remaining / animation.duration || 0,
 305                                 percent = 1 - temp,
 306                                 index = 0,
 307                                 length = animation.tweens.length;
 308
 309                         for ( ; index < length ; index++ ) {
 310                                 animation.tweens[ index ].run( percent );
 311                         }
 312
 313                         deferred.notifyWith( elem, [ animation, percent, remaining ]);
 314
 315                         if ( percent < 1 && length ) {
 316                                 return remaining;
 317                         } else {
 318                                 deferred.resolveWith( elem, [ animation ] );
 319                                 return false;
 320                         }
 321                 },
 322                 animation = deferred.promise({
 323                         elem: elem,
 324                         props: jQuery.extend( {}, properties ),
 325                         opts: jQuery.extend( true, { specialEasing: {} }, options ),
 326                         originalProperties: properties,
 327                         originalOptions: options,
 328                         startTime: fxNow || createFxNow(),
 329                         duration: options.duration,
 330                         tweens: [],
 331                         createTween: function( prop, end ) {
 332                                 var tween = jQuery.Tween( elem, animation.opts, prop, end,
 333                                                 animation.opts.specialEasing[ prop ] || animation.opts.easing );
 334                                 animation.tweens.push( tween );
 335                                 return tween;
 336                         },
 337                         stop: function( gotoEnd ) {
 338                                 var index = 0,
 339                                         // If we are going to the end, we want to run all the tweens
 340                                         // otherwise we skip this part
 341                                         length = gotoEnd ? animation.tweens.length : 0;
 342                                 if ( stopped ) {
 343                                         return this;
 344                                 }
 345                                 stopped = true;
 346                                 for ( ; index < length ; index++ ) {
 347                                         animation.tweens[ index ].run( 1 );
 348                                 }
 349
 350                                 // Resolve when we played the last frame; otherwise, reject
 351                                 if ( gotoEnd ) {
 352                                         deferred.resolveWith( elem, [ animation, gotoEnd ] );
 353                                 } else {
 354                                         deferred.rejectWith( elem, [ animation, gotoEnd ] );
 355                                 }
 356                                 return this;
 357                         }
 358                 }),
 359                 props = animation.props;
 360
 361         propFilter( props, animation.opts.specialEasing );
 362
 363         for ( ; index < length ; index++ ) {
 364                 result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
 365                 if ( result ) {
 366                         return result;
 367                 }
 368         }
 369
 370         jQuery.map( props, createTween, animation );
 371
 372         if ( jQuery.isFunction( animation.opts.start ) ) {
 373                 animation.opts.start.call( elem, animation );
 374         }
 375
 376         jQuery.fx.timer(
 377                 jQuery.extend( tick, {
 378                         elem: elem,
 379                         anim: animation,
 380                         queue: animation.opts.queue
 381                 })
 382         );
 383
 384         // attach callbacks from options
 385         return animation.progress( animation.opts.progress )
 386                 .done( animation.opts.done, animation.opts.complete )
 387                 .fail( animation.opts.fail )
 388                 .always( animation.opts.always );
 389 }
 390
 391 jQuery.Animation = jQuery.extend( Animation, {
 392
 393         tweener: function( props, callback ) {
 394                 if ( jQuery.isFunction( props ) ) {
 395                         callback = props;
 396                         props = [ "*" ];
 397                 } else {
 398                         props = props.split(" ");
 399                 }
 400
 401                 var prop,
 402                         index = 0,
 403                         length = props.length;
 404
 405                 for ( ; index < length ; index++ ) {
 406                         prop = props[ index ];
 407                         tweeners[ prop ] = tweeners[ prop ] || [];
 408                         tweeners[ prop ].unshift( callback );
 409                 }
 410         },
 411
 412         prefilter: function( callback, prepend ) {
 413                 if ( prepend ) {
 414                         animationPrefilters.unshift( callback );
 415                 } else {
 416                         animationPrefilters.push( callback );
 417                 }
 418         }
 419 });
 420
 421 jQuery.speed = function( speed, easing, fn ) {
 422         var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
 423                 complete: fn || !fn && easing ||
 424                         jQuery.isFunction( speed ) && speed,
 425                 duration: speed,
 426                 easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
 427         };
 428
 429         opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
 430                 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
 431
 432         // Normalize opt.queue - true/undefined/null -> "fx"
 433         if ( opt.queue == null || opt.queue === true ) {
 434                 opt.queue = "fx";
 435         }
 436
 437         // Queueing
 438         opt.old = opt.complete;
 439
 440         opt.complete = function() {
 441                 if ( jQuery.isFunction( opt.old ) ) {
 442                         opt.old.call( this );
 443                 }
 444
 445                 if ( opt.queue ) {
 446                         jQuery.dequeue( this, opt.queue );
 447                 }
 448         };
 449
 450         return opt;
 451 };
 452
 453 jQuery.fn.extend({
 454         fadeTo: function( speed, to, easing, callback ) {
 455
 456                 // Show any hidden elements after setting opacity to 0
 457                 return this.filter( isHidden ).css( "opacity", 0 ).show()
 458
 459                         // Animate to the value specified
 460                         .end().animate({ opacity: to }, speed, easing, callback );
 461         },
 462         animate: function( prop, speed, easing, callback ) {
 463                 var empty = jQuery.isEmptyObject( prop ),
 464                         optall = jQuery.speed( speed, easing, callback ),
 465                         doAnimation = function() {
 466                                 // Operate on a copy of prop so per-property easing won't be lost
 467                                 var anim = Animation( this, jQuery.extend( {}, prop ), optall );
 468
 469                                 // Empty animations, or finishing resolves immediately
 470                                 if ( empty || data_priv.get( this, "finish" ) ) {
 471                                         anim.stop( true );
 472                                 }
 473                         };
 474                         doAnimation.finish = doAnimation;
 475
 476                 return empty || optall.queue === false ?
 477                         this.each( doAnimation ) :
 478                         this.queue( optall.queue, doAnimation );
 479         },
 480         stop: function( type, clearQueue, gotoEnd ) {
 481                 var stopQueue = function( hooks ) {
 482                         var stop = hooks.stop;
 483                         delete hooks.stop;
 484                         stop( gotoEnd );
 485                 };
 486
 487                 if ( typeof type !== "string" ) {
 488                         gotoEnd = clearQueue;
 489                         clearQueue = type;
 490                         type = undefined;
 491                 }
 492                 if ( clearQueue && type !== false ) {
 493                         this.queue( type || "fx", [] );
 494                 }
 495
 496                 return this.each(function() {
 497                         var dequeue = true,
 498                                 index = type != null && type + "queueHooks",
 499                                 timers = jQuery.timers,
 500                                 data = data_priv.get( this );
 501
 502                         if ( index ) {
 503                                 if ( data[ index ] && data[ index ].stop ) {
 504                                         stopQueue( data[ index ] );
 505                                 }
 506                         } else {
 507                                 for ( index in data ) {
 508                                         if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
 509                                                 stopQueue( data[ index ] );
 510                                         }
 511                                 }
 512                         }
 513
 514                         for ( index = timers.length; index--; ) {
 515                                 if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
 516                                         timers[ index ].anim.stop( gotoEnd );
 517                                         dequeue = false;
 518                                         timers.splice( index, 1 );
 519                                 }
 520                         }
 521
 522                         // Start the next in the queue if the last step wasn't forced.
 523                         // Timers currently will call their complete callbacks, which
 524                         // will dequeue but only if they were gotoEnd.
 525                         if ( dequeue || !gotoEnd ) {
 526                                 jQuery.dequeue( this, type );
 527                         }
 528                 });
 529         },
 530         finish: function( type ) {
 531                 if ( type !== false ) {
 532                         type = type || "fx";
 533                 }
 534                 return this.each(function() {
 535                         var index,
 536                                 data = data_priv.get( this ),
 537                                 queue = data[ type + "queue" ],
 538                                 hooks = data[ type + "queueHooks" ],
 539                                 timers = jQuery.timers,
 540                                 length = queue ? queue.length : 0;
 541
 542                         // Enable finishing flag on private data
 543                         data.finish = true;
 544
 545                         // Empty the queue first
 546                         jQuery.queue( this, type, [] );
 547
 548                         if ( hooks && hooks.stop ) {
 549                                 hooks.stop.call( this, true );
 550                         }
 551
 552                         // Look for any active animations, and finish them
 553                         for ( index = timers.length; index--; ) {
 554                                 if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
 555                                         timers[ index ].anim.stop( true );
 556                                         timers.splice( index, 1 );
 557                                 }
 558                         }
 559
 560                         // Look for any animations in the old queue and finish them
 561                         for ( index = 0; index < length; index++ ) {
 562                                 if ( queue[ index ] && queue[ index ].finish ) {
 563                                         queue[ index ].finish.call( this );
 564                                 }
 565                         }
 566
 567                         // Turn off finishing flag
 568                         delete data.finish;
 569                 });
 570         }
 571 });
 572
 573 jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
 574         var cssFn = jQuery.fn[ name ];
 575         jQuery.fn[ name ] = function( speed, easing, callback ) {
 576                 return speed == null || typeof speed === "boolean" ?
 577                         cssFn.apply( this, arguments ) :
 578                         this.animate( genFx( name, true ), speed, easing, callback );
 579         };
 580 });
 581
 582 // Generate shortcuts for custom animations
 583 jQuery.each({
 584         slideDown: genFx("show"),
 585         slideUp: genFx("hide"),
 586         slideToggle: genFx("toggle"),
 587         fadeIn: { opacity: "show" },
 588         fadeOut: { opacity: "hide" },
 589         fadeToggle: { opacity: "toggle" }
 590 }, function( name, props ) {
 591         jQuery.fn[ name ] = function( speed, easing, callback ) {
 592                 return this.animate( props, speed, easing, callback );
 593         };
 594 });
 595
 596 jQuery.timers = [];
 597 jQuery.fx.tick = function() {
 598         var timer,
 599                 i = 0,
 600                 timers = jQuery.timers;
 601
 602         fxNow = jQuery.now();
 603
 604         for ( ; i < timers.length; i++ ) {
 605                 timer = timers[ i ];
 606                 // Checks the timer has not already been removed
 607                 if ( !timer() && timers[ i ] === timer ) {
 608                         timers.splice( i--, 1 );
 609                 }
 610         }
 611
 612         if ( !timers.length ) {
 613                 jQuery.fx.stop();
 614         }
 615         fxNow = undefined;
 616 };
 617
 618 jQuery.fx.timer = function( timer ) {
 619         jQuery.timers.push( timer );
 620         if ( timer() ) {
 621                 jQuery.fx.start();
 622         } else {
 623                 jQuery.timers.pop();
 624         }
 625 };
 626
 627 jQuery.fx.interval = 13;
 628
 629 jQuery.fx.start = function() {
 630         if ( !timerId ) {
 631                 timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
 632         }
 633 };
 634
 635 jQuery.fx.stop = function() {
 636         clearInterval( timerId );
 637         timerId = null;
 638 };
 639
 640 jQuery.fx.speeds = {
 641         slow: 600,
 642         fast: 200,
 643         // Default speed
 644         _default: 400
 645 };
 646
 647 return jQuery;
 648 });