JAVASCRIPT   67

css.js

Guest on 24th August 2021 06:18:16 PM

  1. define([
  2.         "./core",
  3.         "./var/pnum",
  4.         "./core/access",
  5.         "./css/var/rmargin",
  6.         "./css/var/rnumnonpx",
  7.         "./css/var/cssExpand",
  8.         "./css/var/isHidden",
  9.         "./css/var/getStyles",
  10.         "./css/curCSS",
  11.         "./css/defaultDisplay",
  12.         "./css/addGetHookIf",
  13.         "./css/support",
  14.         "./data/var/data_priv",
  15.  
  16.         "./core/init",
  17.         "./css/swap",
  18.         "./core/ready",
  19.         "./selector" // contains
  20. ], function( jQuery, pnum, access, rmargin, rnumnonpx, cssExpand, isHidden,
  21.         getStyles, curCSS, defaultDisplay, addGetHookIf, support, data_priv ) {
  22.  
  23. var
  24.         // Swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
  25.         // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
  26.         rdisplayswap = /^(none|table(?!-c[ea]).+)/,
  27.         rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
  28.         rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
  29.  
  30.         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  31.         cssNormalTransform = {
  32.                 letterSpacing: "0",
  33.                 fontWeight: "400"
  34.         },
  35.  
  36.         cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
  37.  
  38. // Return a css property mapped to a potentially vendor prefixed property
  39. function vendorPropName( style, name ) {
  40.  
  41.         // Shortcut for names that are not vendor prefixed
  42.         if ( name in style ) {
  43.                 return name;
  44.         }
  45.  
  46.         // Check for vendor prefixed names
  47.         var capName = name[0].toUpperCase() + name.slice(1),
  48.                 origName = name,
  49.                 i = cssPrefixes.length;
  50.  
  51.         while ( i-- ) {
  52.                 name = cssPrefixes[ i ] + capName;
  53.                 if ( name in style ) {
  54.                         return name;
  55.                 }
  56.         }
  57.  
  58.         return origName;
  59. }
  60.  
  61. function setPositiveNumber( elem, value, subtract ) {
  62.         var matches = rnumsplit.exec( value );
  63.         return matches ?
  64.                 // Guard against undefined "subtract", e.g., when used as in cssHooks
  65.                 Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
  66.                 value;
  67. }
  68.  
  69. function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
  70.         var i = extra === ( isBorderBox ? "border" : "content" ) ?
  71.                 // If we already have the right measurement, avoid augmentation
  72.                 4 :
  73.                 // Otherwise initialize for horizontal or vertical properties
  74.                 name === "width" ? 1 : 0,
  75.  
  76.                 val = 0;
  77.  
  78.         for ( ; i < 4; i += 2 ) {
  79.                 // Both box models exclude margin, so add it if we want it
  80.                 if ( extra === "margin" ) {
  81.                         val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
  82.                 }
  83.  
  84.                 if ( isBorderBox ) {
  85.                         // border-box includes padding, so remove it if we want content
  86.                         if ( extra === "content" ) {
  87.                                 val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  88.                         }
  89.  
  90.                         // At this point, extra isn't border nor margin, so remove border
  91.                         if ( extra !== "margin" ) {
  92.                                 val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  93.                         }
  94.                 } else {
  95.                         // At this point, extra isn't content, so add padding
  96.                         val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  97.  
  98.                         // At this point, extra isn't content nor padding, so add border
  99.                         if ( extra !== "padding" ) {
  100.                                 val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  101.                         }
  102.                 }
  103.         }
  104.  
  105.         return val;
  106. }
  107.  
  108. function getWidthOrHeight( elem, name, extra ) {
  109.  
  110.         // Start with offset property, which is equivalent to the border-box value
  111.         var valueIsBorderBox = true,
  112.                 val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
  113.                 styles = getStyles( elem ),
  114.                 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
  115.  
  116.         // Some non-html elements return undefined for offsetWidth, so check for null/undefined
  117.         // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
  118.         // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
  119.         if ( val <= 0 || val == null ) {
  120.                 // Fall back to computed then uncomputed css if necessary
  121.                 val = curCSS( elem, name, styles );
  122.                 if ( val < 0 || val == null ) {
  123.                         val = elem.style[ name ];
  124.                 }
  125.  
  126.                 // Computed unit is not pixels. Stop here and return.
  127.                 if ( rnumnonpx.test(val) ) {
  128.                         return val;
  129.                 }
  130.  
  131.                 // Check for style in case a browser which returns unreliable values
  132.                 // for getComputedStyle silently falls back to the reliable elem.style
  133.                 valueIsBorderBox = isBorderBox &&
  134.                         ( support.boxSizingReliable() || val === elem.style[ name ] );
  135.  
  136.                 // Normalize "", auto, and prepare for extra
  137.                 val = parseFloat( val ) || 0;
  138.         }
  139.  
  140.         // Use the active box-sizing model to add/subtract irrelevant styles
  141.         return ( val +
  142.                 augmentWidthOrHeight(
  143.                         elem,
  144.                         name,
  145.                         extra || ( isBorderBox ? "border" : "content" ),
  146.                         valueIsBorderBox,
  147.                         styles
  148.                 )
  149.         ) + "px";
  150. }
  151.  
  152. function showHide( elements, show ) {
  153.         var display, elem, hidden,
  154.                 values = [],
  155.                 index = 0,
  156.                 length = elements.length;
  157.  
  158.         for ( ; index < length; index++ ) {
  159.                 elem = elements[ index ];
  160.                 if ( !elem.style ) {
  161.                         continue;
  162.                 }
  163.  
  164.                 values[ index ] = data_priv.get( elem, "olddisplay" );
  165.                 display = elem.style.display;
  166.                 if ( show ) {
  167.                         // Reset the inline display of this element to learn if it is
  168.                         // being hidden by cascaded rules or not
  169.                         if ( !values[ index ] && display === "none" ) {
  170.                                 elem.style.display = "";
  171.                         }
  172.  
  173.                         // Set elements which have been overridden with display: none
  174.                         // in a stylesheet to whatever the default browser style is
  175.                         // for such an element
  176.                         if ( elem.style.display === "" && isHidden( elem ) ) {
  177.                                 values[ index ] = data_priv.access( elem, "olddisplay", defaultDisplay(elem.nodeName) );
  178.                         }
  179.                 } else {
  180.                         hidden = isHidden( elem );
  181.  
  182.                         if ( display !== "none" || !hidden ) {
  183.                                 data_priv.set( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
  184.                         }
  185.                 }
  186.         }
  187.  
  188.         // Set the display of most of the elements in a second loop
  189.         // to avoid the constant reflow
  190.         for ( index = 0; index < length; index++ ) {
  191.                 elem = elements[ index ];
  192.                 if ( !elem.style ) {
  193.                         continue;
  194.                 }
  195.                 if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
  196.                         elem.style.display = show ? values[ index ] || "" : "none";
  197.                 }
  198.         }
  199.  
  200.         return elements;
  201. }
  202.  
  203. jQuery.extend({
  204.  
  205.         // Add in style property hooks for overriding the default
  206.         // behavior of getting and setting a style property
  207.         cssHooks: {
  208.                 opacity: {
  209.                         get: function( elem, computed ) {
  210.                                 if ( computed ) {
  211.  
  212.                                         // We should always get a number back from opacity
  213.                                         var ret = curCSS( elem, "opacity" );
  214.                                         return ret === "" ? "1" : ret;
  215.                                 }
  216.                         }
  217.                 }
  218.         },
  219.  
  220.         // Don't automatically add "px" to these possibly-unitless properties
  221.         cssNumber: {
  222.                 "columnCount": true,
  223.                 "fillOpacity": true,
  224.                 "flexGrow": true,
  225.                 "flexShrink": true,
  226.                 "fontWeight": true,
  227.                 "lineHeight": true,
  228.                 "opacity": true,
  229.                 "order": true,
  230.                 "orphans": true,
  231.                 "widows": true,
  232.                 "zIndex": true,
  233.                 "zoom": true
  234.         },
  235.  
  236.         // Add in properties whose names you wish to fix before
  237.         // setting or getting the value
  238.         cssProps: {
  239.                 "float": "cssFloat"
  240.         },
  241.  
  242.         // Get and set the style property on a DOM Node
  243.         style: function( elem, name, value, extra ) {
  244.  
  245.                 // Don't set styles on text and comment nodes
  246.                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
  247.                         return;
  248.                 }
  249.  
  250.                 // Make sure that we're working with the right name
  251.                 var ret, type, hooks,
  252.                         origName = jQuery.camelCase( name ),
  253.                         style = elem.style;
  254.  
  255.                 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
  256.  
  257.                 // Gets hook for the prefixed version, then unprefixed version
  258.                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  259.  
  260.                 // Check if we're setting a value
  261.                 if ( value !== undefined ) {
  262.                         type = typeof value;
  263.  
  264.                         // Convert "+=" or "-=" to relative numbers (#7345)
  265.                         if ( type === "string" && (ret = rrelNum.exec( value )) ) {
  266.                                 value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
  267.                                 // Fixes bug #9237
  268.                                 type = "number";
  269.                         }
  270.  
  271.                         // Make sure that null and NaN values aren't set (#7116)
  272.                         if ( value == null || value !== value ) {
  273.                                 return;
  274.                         }
  275.  
  276.                         // If a number, add 'px' to the (except for certain CSS properties)
  277.                         if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
  278.                                 value += "px";
  279.                         }
  280.  
  281.                         // Support: IE9-11+
  282.                         // background-* props affect original clone's values
  283.                         if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
  284.                                 style[ name ] = "inherit";
  285.                         }
  286.  
  287.                         // If a hook was provided, use that value, otherwise just set the specified value
  288.                         if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
  289.                                 style[ name ] = value;
  290.                         }
  291.  
  292.                 } else {
  293.                         // If a hook was provided get the non-computed value from there
  294.                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
  295.                                 return ret;
  296.                         }
  297.  
  298.                         // Otherwise just get the value from the style object
  299.                         return style[ name ];
  300.                 }
  301.         },
  302.  
  303.         css: function( elem, name, extra, styles ) {
  304.                 var val, num, hooks,
  305.                         origName = jQuery.camelCase( name );
  306.  
  307.                 // Make sure that we're working with the right name
  308.                 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
  309.  
  310.                 // Try prefixed name followed by the unprefixed name
  311.                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  312.  
  313.                 // If a hook was provided get the computed value from there
  314.                 if ( hooks && "get" in hooks ) {
  315.                         val = hooks.get( elem, true, extra );
  316.                 }
  317.  
  318.                 // Otherwise, if a way to get the computed value exists, use that
  319.                 if ( val === undefined ) {
  320.                         val = curCSS( elem, name, styles );
  321.                 }
  322.  
  323.                 // Convert "normal" to computed value
  324.                 if ( val === "normal" && name in cssNormalTransform ) {
  325.                         val = cssNormalTransform[ name ];
  326.                 }
  327.  
  328.                 // Make numeric if forced or a qualifier was provided and val looks numeric
  329.                 if ( extra === "" || extra ) {
  330.                         num = parseFloat( val );
  331.                         return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
  332.                 }
  333.                 return val;
  334.         }
  335. });
  336.  
  337. jQuery.each([ "height", "width" ], function( i, name ) {
  338.         jQuery.cssHooks[ name ] = {
  339.                 get: function( elem, computed, extra ) {
  340.                         if ( computed ) {
  341.  
  342.                                 // Certain elements can have dimension info if we invisibly show them
  343.                                 // but it must have a current display style that would benefit
  344.                                 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?
  345.                                         jQuery.swap( elem, cssShow, function() {
  346.                                                 return getWidthOrHeight( elem, name, extra );
  347.                                         }) :
  348.                                         getWidthOrHeight( elem, name, extra );
  349.                         }
  350.                 },
  351.  
  352.                 set: function( elem, value, extra ) {
  353.                         var styles = extra && getStyles( elem );
  354.                         return setPositiveNumber( elem, value, extra ?
  355.                                 augmentWidthOrHeight(
  356.                                         elem,
  357.                                         name,
  358.                                         extra,
  359.                                         jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
  360.                                         styles
  361.                                 ) : 0
  362.                         );
  363.                 }
  364.         };
  365. });
  366.  
  367. // Support: Android 2.3
  368. jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
  369.         function( elem, computed ) {
  370.                 if ( computed ) {
  371.                         return jQuery.swap( elem, { "display": "inline-block" },
  372.                                 curCSS, [ elem, "marginRight" ] );
  373.                 }
  374.         }
  375. );
  376.  
  377. // These hooks are used by animate to expand properties
  378. jQuery.each({
  379.         margin: "",
  380.         padding: "",
  381.         border: "Width"
  382. }, function( prefix, suffix ) {
  383.         jQuery.cssHooks[ prefix + suffix ] = {
  384.                 expand: function( value ) {
  385.                         var i = 0,
  386.                                 expanded = {},
  387.  
  388.                                 // Assumes a single number if not a string
  389.                                 parts = typeof value === "string" ? value.split(" ") : [ value ];
  390.  
  391.                         for ( ; i < 4; i++ ) {
  392.                                 expanded[ prefix + cssExpand[ i ] + suffix ] =
  393.                                         parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
  394.                         }
  395.  
  396.                         return expanded;
  397.                 }
  398.         };
  399.  
  400.         if ( !rmargin.test( prefix ) ) {
  401.                 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
  402.         }
  403. });
  404.  
  405. jQuery.fn.extend({
  406.         css: function( name, value ) {
  407.                 return access( this, function( elem, name, value ) {
  408.                         var styles, len,
  409.                                 map = {},
  410.                                 i = 0;
  411.  
  412.                         if ( jQuery.isArray( name ) ) {
  413.                                 styles = getStyles( elem );
  414.                                 len = name.length;
  415.  
  416.                                 for ( ; i < len; i++ ) {
  417.                                         map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
  418.                                 }
  419.  
  420.                                 return map;
  421.                         }
  422.  
  423.                         return value !== undefined ?
  424.                                 jQuery.style( elem, name, value ) :
  425.                                 jQuery.css( elem, name );
  426.                 }, name, value, arguments.length > 1 );
  427.         },
  428.         show: function() {
  429.                 return showHide( this, true );
  430.         },
  431.         hide: function() {
  432.                 return showHide( this );
  433.         },
  434.         toggle: function( state ) {
  435.                 if ( typeof state === "boolean" ) {
  436.                         return state ? this.show() : this.hide();
  437.                 }
  438.  
  439.                 return this.each(function() {
  440.                         if ( isHidden( this ) ) {
  441.                                 jQuery( this ).show();
  442.                         } else {
  443.                                 jQuery( this ).hide();
  444.                         }
  445.                 });
  446.         }
  447. });
  448.  
  449. return jQuery;
  450. });

Raw Paste


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