Changeset 110469 in spip-zone


Ignore:
Timestamp:
Jun 1, 2018, 7:47:02 AM (15 months ago)
Author:
arnaud.berard@…
Message:

mise a jour de la lib en 4.0.2

nettoyage des fichiers minifiés inutiles dans le plugins spip

Location:
_plugins_/lazysizes/trunk
Files:
20 deleted
17 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/lazysizes/trunk/README.md

    r105475 r110469  
    3030Lazysizes est conçut différement des autres scripts de lazyload d'image.
    3131
    32 Il detecte automatiquement les changement de visibilité affectant l'élément courrant a précharger
    33 ainsi que les suivant, et ce dans n'importe quel environement :
     32Il detecte automatiquement les changement de visibilité affectant l'élément courant a précharger
     33ainsi que les suivant, et ce dans n'importe quel environnement :
    3434
    3535Le script fonctionne de manière autonome, auto initialisé, auto configuré,
     
    5757It's based on highly efficient, best practice code (runtime and network)
    5858to work jank-free at 60fps and can be used with hundreds of images/iframes on CSS and JS-heavy pages or webapps.
    59        
     59
    6060**Extendable** :
    6161
     
    186186- []    preview des modeles dans l'espace privé
    187187                par exemple : `<picture5|id_document=5>`
    188                
     188
    189189- [X] config export ie_config()
    190 - [] traduire la doc 
     190- [] traduire la doc
    191191- [] Ajouter via define ou config les options de configuration
    192192- [] surcharger les modèles media, interressants a "lazyloader"
  • _plugins_/lazysizes/trunk/inc/safehtml.php

    r106783 r110469  
    3030        $config->set('CSS.AllowTricky', true);
    3131        $config->set('HTML.Allowed', $allowed);
     32        //https://stackoverflow.com/questions/11747918/htmlpurifier-allow-class-attribute
     33        //$config->set('HTML.AllowedAttributes', 'img.src,*.class');
    3234        $config->set('Attr.AllowedFrameTargets', array('_blank'=>true));
    3335       
    3436        //$config->set('HTML.TargetBlank', true);
    3537        //$config->set('HTML.TargetNoopener', true);
    36         $config->set('Cache.SerializerPath', preg_replace(',/$,', '', realpath(_DIR_TMP)));
     38        $config->set('Cache.SerializerPath', preg_replace(',/$,', '', realpath(_DIR_TMP.'cache/')));
     39       
     40          // Set some HTML5 properties
     41        //$config->set('HTML.DefinitionID', 'html5-definitions'); // unqiue id
     42        //$config->set('HTML.DefinitionRev', 1);
     43 
    3744        $def = $config->getHTMLDefinition(true);
    3845         
     
    93100        $def->addAttribute('img', 'data-sizes', 'CDATA');
    94101       
     102        $def->addAttribute('a', 'class', 'Text');
     103        $def->addAttribute('a', 'href', 'URI');
    95104        //var_dump($def);
    96105        if (!isset($purifier))
  • _plugins_/lazysizes/trunk/javascript/addons/artdirect/ls.artdirect.js

    r105556 r110469  
    2929
    3030        function getCandidatesAspectRatio(element){
     31                var match;
    3132                var ratio = parseFloat(element.getAttribute('data-aspectratio'));
    3233                var srcset = element.getAttribute(lazySizesConfig.srcsetAttr) || element.getAttribute('srcset');
    3334
    34                 if(!ratio && srcset.match(regDescriptors)){
    35                         if(RegExp.$2 == 'w'){
    36                                 ratio = RegExp.$1 / RegExp.$3;
     35                if(!ratio && (match = srcset.match(regDescriptors))){
     36                        if(match[2] == 'w'){
     37                                ratio = match[1] / match[3];
    3738                        } else {
    38                                 ratio = RegExp.$3 / RegExp.$1;
     39                                ratio = match[3] / match[1];
    3940                        }
    4041                }
  • _plugins_/lazysizes/trunk/javascript/addons/aspectratio/ls.aspectratio.js

    r105556 r110469  
    134134                        var ratioCache = {};
    135135                        return function(ratio){
    136 
    137                                 if(!ratioCache[ratio] && ratio.match(regRatio)){
    138                                         if(RegExp.$3){
    139                                                 ratioCache[ratio] = RegExp.$1 / RegExp.$3;
     136                                var match;
     137
     138                                if(!ratioCache[ratio] && (match = ratio.match(regRatio))){
     139                                        if(match[3]){
     140                                                ratioCache[ratio] = match[1] / match[3];
    140141                                        } else {
    141                                                 ratioCache[ratio] = RegExp.$1 * 1;
     142                                                ratioCache[ratio] = match[1] * 1;
    142143                                        }
    143144                                }
  • _plugins_/lazysizes/trunk/javascript/addons/bgset/ls.bgset.js

    r105556 r110469  
    7171
    7272                sets.forEach(function(set){
     73                        var match;
    7374                        var source = document.createElement('source');
    7475
     
    7778                        }
    7879
    79                         if(set.match(regSource)){
    80                                 source.setAttribute(lazySizesConfig.srcsetAttr, RegExp.$1);
    81                                 if(RegExp.$2){
    82                                         source.setAttribute('media', lazySizesConfig.customMedia[RegExp.$2] || RegExp.$2);
     80                        if((match = set.match(regSource))){
     81                                source.setAttribute(lazySizesConfig.srcsetAttr, match[1]);
     82                                if(match[2]){
     83                                        source.setAttribute('media', lazySizesConfig.customMedia[match[2]] || match[2]);
    8384                                }
    8485                        }
  • _plugins_/lazysizes/trunk/javascript/addons/custommedia/ls.custommedia.js

    r105556 r110469  
    3535                var parse = function(string, object){
    3636                        string.split(regSplit).forEach(function(query){
    37                                 if(query.match(regNamedQueries)){
    38                                         object[RegExp.$1] = RegExp.$2;
     37                                var match = query.match(regNamedQueries);
     38
     39                                if(match){
     40                                        object[match[1]] = match[2];
    3941                                }
    4042                        });
  • _plugins_/lazysizes/trunk/javascript/addons/include/README.md

    r105556 r110469  
    126126```
    127127
    128 In case content and a behavior include is used together lazySizes will load them in parallel but makes sure to first include the content and then initialize the behavior. 
     128In case content and a behavior include is used together lazySizes will load them in parallel but makes sure to first include the content and then initialize the behavior.
    129129
    130130#### AMD/ES6 module features
     
    258258* ``lazyincludeloaded`` is a cancelable event fired at the element after the request is complete, but before the content is added. The ``event.detail.content`` property can be used to modify the content (for example to transform JSON to HTML).
    259259* ``lazyincluded`` is an event fired at the element right after the HTML was injected.
     260
     261Here are some examples:
     262
     263```js
     264const component = document.querySelector('.lazy-component');
     265
     266// Modify the request headers when the targeted component kicks off an XHR
     267component.addEventListener('lazyincludeload', function(event) {
     268  if (event.detail) {
     269    event.detail.xhrModifier = function(request, candidate) {
     270      request.setRequestHeader('Accept', 'application/json');
     271    }
     272  }
     273});
     274
     275// Transform a JSON response into HTML before it is injected
     276component.addEventListener('lazyincludeloaded', function(event) {
     277  if (event.detail.content) {
     278    var json = JSON.parse(event.detail.content);
     279    var html = '<h1>' + json.title + '</h1>';
     280    html += '<div>' + json.body + '</div>';
     281    event.detail.content = html;
     282  }
     283});
     284```
    260285
    261286### Options
     
    386411
    387412        Nav.prototype = {
    388                
     413
    389414        };
    390415
     
    397422        };
    398423        };
    399    
     424
    400425        Nav.lazyload = function(data){
    401426        //check wether mobileNav has shared some data
  • _plugins_/lazysizes/trunk/javascript/addons/include/ls.include.js

    r105556 r110469  
    153153        function addUrl(url){
    154154                /*jshint validthis:true */
    155                 if(url.match(regTypes)){
    156                         this.urls[RegExp.$1] = includeConfig.map[RegExp.$2] || RegExp.$2;
     155                var match;
     156                if((match = url.match(regTypes))){
     157                        this.urls[match[1]] = includeConfig.map[match[2]] || match[2];
    157158                } else {
    158159                        this.urls.include = includeConfig.map[url] || url;
     
    169170
    170171                if(map){
    171                         url = RegExp.$1;
     172                        url = map[1];
    172173                        output = {
    173                                 condition: config.include.conditions[RegExp.$3] || config.customMedia[RegExp.$3] || RegExp.$2 || null,
    174                                 name: RegExp.$3
     174                                condition: config.include.conditions[map[3]] || config.customMedia[map[3]] || map[2] || null,
     175                                name: map[3]
    175176                        };
    176177                } else {
     
    312313                request.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
    313314                if(detail.xhrModifier){
    314                         detail.xhrModifier(request, elem, candidate);
     315                        detail.xhrModifier(request, detail.candidate);
    315316                }
    316317                request.send(detail.sendData);
     
    402403
    403404                include = function(){
    404                         var event, loadRequireImportCB;
     405                        var event;
    405406                        var status = xhrObj.status;
    406407                        var content = xhrObj.content || xhrObj.responseText;
     
    469470
    470471                if(candidate.urls.amd || candidate.urls.module){
    471                         loadRequireImportCB = function(){
     472                        var loadRequireImportCB = function(){
    472473                                modules = Array.prototype.slice.call(arguments);
    473474                                if(xhrObj){
  • _plugins_/lazysizes/trunk/javascript/addons/object-fit/README.md

    r105556 r110469  
    99
    1010```html
     11<!-- polyfill for object-fit (only needed in browsers that don't support object-fit) -->
     12<script src="../plugins/object-fit/ls.object-fit.min.js"></script>
    1113<!-- required: -->
    12 <script src="../plugins/object-fit/ls.object-fit.min.js"></script>
    1314<script src="../lazysizes.min.js" async=""></script>
    1415
    15 <!-- only for data-sizes="auto" in combination with object fit -->
     16<!-- only for data-sizes="auto" in combination with object-fit CSS property (native or polyfill) -->
    1617<script src="../plugins/parent-fit/ls.parent-fit.min.js"></script>
    17 <!-- only for respimg support -->
     18<!-- respimg polyfill (only needed in browser that don't support respimg) -->
    1819<script src="../plugins/respimg/ls.respimg.min.js"></script>
    1920```
  • _plugins_/lazysizes/trunk/javascript/addons/object-fit/ls.object-fit.js

    r105556 r110469  
    4545
    4646        function initFix(element, config){
    47                 var switchClassesAdded;
     47                var switchClassesAdded, addedSrc;
    4848                var lazysizesCfg = lazySizes.cfg;
    4949                var styleElement = element.cloneNode(false);
     
    5353                        var src = element.currentSrc || element.src;
    5454
    55                         if(src){
     55                        if(src && addedSrc !== src){
     56                                addedSrc = src;
    5657                                styleElementStyle.backgroundImage = 'url(' + (regBgUrlEscape.test(src) ? JSON.stringify(src) : src ) + ')';
    5758
     
    6364                        }
    6465                };
     66                var rafedOnChange = function(){
     67                        lazySizes.rAF(onChange);
     68                };
    6569
    6670                element._lazysizesParentFit = config.fit;
    6771
    68                 element.addEventListener('load', function(){
    69                         lazySizes.rAF(onChange);
    70                 }, true);
     72                element.addEventListener('lazyloaded', rafedOnChange, true);
     73                element.addEventListener('load', rafedOnChange, true);
    7174
    7275                styleElement.addEventListener('load', function(){
  • _plugins_/lazysizes/trunk/javascript/addons/optimumx/README.md

    r105556 r110469  
    8484<script>
    8585window.lazySizesConfig = window.lazySizesConfig || {};
    86 window.lazySizesConfig.getOptimumX = function(element){
     86window.lazySizesConfig.getOptimumX = function(_element){
    8787    return window.devicePixelRatio > 1.6 ? devicePixelRatio * 0.9 : 1;
    8888};
     
    116116    return Math.min(Math.round(dpr * 100) / 100, 2);
    117117};
     118```
     119
     120### The `constrainPixelDensity` option
     121
     122In case the `constrainPixelDensity` is set to `true`. All images without a `data-optimumx` attribute are treated as they would have a `data-optimumx="auto"` attribute.
     123
     124```html
     125<script>
     126window.lazySizesConfig = window.lazySizesConfig || {};
     127window.lazySizesConfig.constrainPixelDensity = true;
     128</script>
     129
     130<img
     131    data-srcset="http://placehold.it/300x150 300w,
     132        http://placehold.it/700x300 700w,
     133        http://placehold.it/1400x600 1400w,
     134        http://placehold.it/2800x1200 2800w"
     135     data-sizes="auto"
     136     class="lazyload"
     137     src="http://placehold.it/300x150"
     138     alt="flexible image" />
    118139```
    119140
  • _plugins_/lazysizes/trunk/javascript/addons/parent-fit/ls.parent-fit.js

    r105556 r110469  
    8585
    8686                getImageRatio: function(element){
    87                         var i, srcset, media, ratio;
     87                        var i, srcset, media, ratio, match;
    8888                        var parent = element.parentNode;
    8989                        var elements = parent && regPicture.test(parent.nodeName || '') ?
     
    101101                                        ratio = parseFloat(element.getAttribute('data-aspectratio'));
    102102
    103                                         if(!ratio && srcset.match(regDescriptors)){
    104                                                 if(RegExp.$2 == 'w'){
    105                                                         ratio = RegExp.$1 / RegExp.$3;
     103                                        if(!ratio && (match = srcset.match(regDescriptors))){
     104                                                if(match[2] == 'w'){
     105                                                        ratio = match[1] / match[3];
    106106                                                } else {
    107                                                         ratio = RegExp.$3 / RegExp.$1;
     107                                                        ratio = match[3] / match[1];
    108108                                                }
    109109                                        }
  • _plugins_/lazysizes/trunk/javascript/addons/respimg/ls.respimg.js

    r105556 r110469  
    2929                        var img = document.createElement('img');
    3030                        var removeHDescriptors = function(source){
    31                                 var ratio;
     31                                var ratio, match;
    3232                                var srcset = source.getAttribute(lazySizesConfig.srcsetAttr);
    3333                                if(srcset){
    34                                         if(srcset.match(regDescriptors)){
    35                                                 if(RegExp.$2 == 'w'){
    36                                                         ratio = RegExp.$1 / RegExp.$3;
     34                                        if((match = srcset.match(regDescriptors))){
     35                                                if(match[2] == 'w'){
     36                                                        ratio = match[1] / match[3];
    3737                                                } else {
    38                                                         ratio = RegExp.$3 / RegExp.$1;
     38                                                        ratio = match[3] / match[1];
    3939                                                }
    4040
  • _plugins_/lazysizes/trunk/javascript/addons/static-gecko-picture/ls.static-gecko-picture.js

    r105556 r110469  
    1919}(window, function(window, document, lazySizes) {
    2020        /*jshint eqnull:true */
     21        var match;
    2122        var ua = navigator.userAgent;
    2223
    23         if ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 < 41) ) {
     24        if ( window.HTMLPictureElement && ((/ecko/).test(ua) && (match = ua.match(/rv\:(\d+)/)) && match[1] < 41) ) {
    2425                addEventListener("resize", (function() {
    2526                        var timer;
  • _plugins_/lazysizes/trunk/javascript/lazysizes.js

    r105556 r110469  
    164164                var running;
    165165                var lastTime = 0;
    166                 var gDelay = 125;
    167                 var RIC_DEFAULT_TIMEOUT = 666;
    168                 var rICTimeout = RIC_DEFAULT_TIMEOUT;
     166                var gDelay = lazySizesConfig.throttleDelay;
     167                var rICTimeout = lazySizesConfig.ricTimeout;
    169168                var run = function(){
    170169                        running = false;
     
    172171                        fn();
    173172                };
    174                 var idleCallback = requestIdleCallback ?
     173                var idleCallback = requestIdleCallback && rICTimeout > 49 ?
    175174                        function(){
    176175                                requestIdleCallback(run, {timeout: rICTimeout});
    177                                 if(rICTimeout !== RIC_DEFAULT_TIMEOUT){
    178                                         rICTimeout = RIC_DEFAULT_TIMEOUT;
    179                                 }
    180                         }:
     176
     177                                if(rICTimeout !== lazySizesConfig.ricTimeout){
     178                                        rICTimeout = lazySizesConfig.ricTimeout;
     179                                }
     180                        } :
    181181                        rAFIt(function(){
    182182                                setTimeout(run);
     
    186186                return function(isPriority){
    187187                        var delay;
     188
    188189                        if((isPriority = isPriority === true)){
    189                                 rICTimeout = 44;
     190                                rICTimeout = 33;
    190191                        }
    191192
     
    202203                        }
    203204
    204                         if(isPriority || (delay < 9 && requestIdleCallback)){
     205                        if(isPriority || delay < 9){
    205206                                idleCallback();
    206207                        } else {
     
    235236                        }
    236237                };
    237         };
    238 
    239 
    240         var loader = (function(){
    241                 var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
    242 
    243                 var eLvW, elvH, eLtop, eLleft, eLright, eLbottom;
    244 
    245                 var defaultExpand, preloadExpand, hFac;
    246 
    247                 var regImg = /^img$/i;
    248                 var regIframe = /^iframe$/i;
    249 
    250                 var supportScroll = ('onscroll' in window) && !(/glebot/.test(navigator.userAgent));
    251 
    252                 var shrinkExpand = 0;
    253                 var currentExpand = 0;
    254 
    255                 var isLoading = 0;
    256                 var lowRuns = -1;
    257 
    258                 var resetPreloading = function(e){
    259                         isLoading--;
    260                         if(e && e.target){
    261                                 addRemoveLoadEvents(e.target, resetPreloading);
    262                         }
    263 
    264                         if(!e || isLoading < 0 || !e.target){
    265                                 isLoading = 0;
    266                         }
    267                 };
    268 
    269                 var isNestedVisible = function(elem, elemExpand){
    270                         var outerRect;
    271                         var parent = elem;
    272                         var visible = getCSS(document.body, 'visibility') == 'hidden' || getCSS(elem, 'visibility') != 'hidden';
    273 
    274                         eLtop -= elemExpand;
    275                         eLbottom += elemExpand;
    276                         eLleft -= elemExpand;
    277                         eLright += elemExpand;
    278 
    279                         while(visible && (parent = parent.offsetParent) && parent != document.body && parent != docElem){
    280                                 visible = ((getCSS(parent, 'opacity') || 1) > 0);
    281 
    282                                 if(visible && getCSS(parent, 'overflow') != 'visible'){
    283                                         outerRect = parent.getBoundingClientRect();
    284                                         visible = eLright > outerRect.left &&
    285                                                 eLleft < outerRect.right &&
    286                                                 eLbottom > outerRect.top - 1 &&
    287                                                 eLtop < outerRect.bottom + 1
    288                                         ;
    289                                 }
    290                         }
    291 
    292                         return visible;
    293                 };
    294 
    295                 var checkElements = function() {
    296                         var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal, beforeExpandVal;
    297 
    298                         var lazyloadElems = lazysizes.elements;
    299 
    300                         if((loadMode = lazySizesConfig.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)){
    301 
    302                                 i = 0;
    303 
    304                                 lowRuns++;
    305 
    306                                 if(preloadExpand == null){
    307                                         if(!('expand' in lazySizesConfig)){
    308                                                 lazySizesConfig.expand = docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370;
    309                                         }
    310 
    311                                         defaultExpand = lazySizesConfig.expand;
    312                                         preloadExpand = defaultExpand * lazySizesConfig.expFactor;
    313                                 }
    314 
    315                                 if(currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document.hidden){
    316                                         currentExpand = preloadExpand;
    317                                         lowRuns = 0;
    318                                 } else if(loadMode > 1 && lowRuns > 1 && isLoading < 6){
    319                                         currentExpand = defaultExpand;
    320                                 } else {
    321                                         currentExpand = shrinkExpand;
    322                                 }
    323 
    324                                 for(; i < eLlen; i++){
    325 
    326                                         if(!lazyloadElems[i] || lazyloadElems[i]._lazyRace){continue;}
    327 
    328                                         if(!supportScroll){unveilElement(lazyloadElems[i]);continue;}
    329 
    330                                         if(!(elemExpandVal = lazyloadElems[i][_getAttribute]('data-expand')) || !(elemExpand = elemExpandVal * 1)){
    331                                                 elemExpand = currentExpand;
    332                                         }
    333 
    334                                         if(beforeExpandVal !== elemExpand){
    335                                                 eLvW = innerWidth + (elemExpand * hFac);
    336                                                 elvH = innerHeight + elemExpand;
    337                                                 elemNegativeExpand = elemExpand * -1;
    338                                                 beforeExpandVal = elemExpand;
    339                                         }
    340 
    341                                         rect = lazyloadElems[i].getBoundingClientRect();
    342 
    343                                         if ((eLbottom = rect.bottom) >= elemNegativeExpand &&
    344                                                 (eLtop = rect.top) <= elvH &&
    345                                                 (eLright = rect.right) >= elemNegativeExpand * hFac &&
    346                                                 (eLleft = rect.left) <= eLvW &&
    347                                                 (eLbottom || eLright || eLleft || eLtop) &&
    348                                                 (lazySizesConfig.loadHidden || getCSS(lazyloadElems[i], 'visibility') != 'hidden') &&
    349                                                 ((isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4)) || isNestedVisible(lazyloadElems[i], elemExpand))){
    350                                                 unveilElement(lazyloadElems[i]);
    351                                                 loadedSomething = true;
    352                                                 if(isLoading > 9){break;}
    353                                         } else if(!loadedSomething && isCompleted && !autoLoadElem &&
    354                                                 isLoading < 4 && lowRuns < 4 && loadMode > 2 &&
    355                                                 (preloadElems[0] || lazySizesConfig.preloadAfterLoad) &&
    356                                                 (preloadElems[0] || (!elemExpandVal && ((eLbottom || eLright || eLleft || eLtop) || lazyloadElems[i][_getAttribute](lazySizesConfig.sizesAttr) != 'auto')))){
    357                                                 autoLoadElem = preloadElems[0] || lazyloadElems[i];
    358                                         }
    359                                 }
    360 
    361                                 if(autoLoadElem && !loadedSomething){
    362                                         unveilElement(autoLoadElem);
    363                                 }
    364                         }
    365                 };
    366 
    367                 var throttledCheckElements = throttle(checkElements);
    368 
    369                 var switchLoadingClass = function(e){
    370                         addClass(e.target, lazySizesConfig.loadedClass);
    371                         removeClass(e.target, lazySizesConfig.loadingClass);
    372                         addRemoveLoadEvents(e.target, rafSwitchLoadingClass);
    373                         triggerEvent(e.target, 'lazyloaded');
    374                 };
    375                 var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
    376                 var rafSwitchLoadingClass = function(e){
    377                         rafedSwitchLoadingClass({target: e.target});
    378                 };
    379 
    380                 var changeIframeSrc = function(elem, src){
    381                         try {
    382                                 elem.contentWindow.location.replace(src);
    383                         } catch(e){
    384                                 elem.src = src;
    385                         }
    386                 };
    387 
    388                 var handleSources = function(source){
    389                         var customMedia;
    390 
    391                         var sourceSrcset = source[_getAttribute](lazySizesConfig.srcsetAttr);
    392 
    393                         if( (customMedia = lazySizesConfig.customMedia[source[_getAttribute]('data-media') || source[_getAttribute]('media')]) ){
    394                                 source.setAttribute('media', customMedia);
    395                         }
    396 
    397                         if(sourceSrcset){
    398                                 source.setAttribute('srcset', sourceSrcset);
    399                         }
    400                 };
    401 
    402                 var lazyUnveil = rAFIt(function (elem, detail, isAuto, sizes, isImg){
    403                         var src, srcset, parent, isPicture, event, firesLoad;
    404 
    405                         if(!(event = triggerEvent(elem, 'lazybeforeunveil', detail)).defaultPrevented){
    406 
    407                                 if(sizes){
    408                                         if(isAuto){
    409                                                 addClass(elem, lazySizesConfig.autosizesClass);
    410                                         } else {
    411                                                 elem.setAttribute('sizes', sizes);
    412                                         }
    413                                 }
    414 
    415                                 srcset = elem[_getAttribute](lazySizesConfig.srcsetAttr);
    416                                 src = elem[_getAttribute](lazySizesConfig.srcAttr);
    417 
    418                                 if(isImg) {
    419                                         parent = elem.parentNode;
    420                                         isPicture = parent && regPicture.test(parent.nodeName || '');
    421                                 }
    422 
    423                                 firesLoad = detail.firesLoad || (('src' in elem) && (srcset || src || isPicture));
    424 
    425                                 event = {target: elem};
    426 
    427                                 if(firesLoad){
    428                                         addRemoveLoadEvents(elem, resetPreloading, true);
    429                                         clearTimeout(resetPreloadingTimer);
    430                                         resetPreloadingTimer = setTimeout(resetPreloading, 2500);
    431 
    432                                         addClass(elem, lazySizesConfig.loadingClass);
    433                                         addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
    434                                 }
    435 
    436                                 if(isPicture){
    437                                         forEach.call(parent.getElementsByTagName('source'), handleSources);
    438                                 }
    439 
    440                                 if(srcset){
    441                                         elem.setAttribute('srcset', srcset);
    442                                 } else if(src && !isPicture){
    443                                         if(regIframe.test(elem.nodeName)){
    444                                                 changeIframeSrc(elem, src);
    445                                         } else {
    446                                                 elem.src = src;
    447                                         }
    448                                 }
    449 
    450                                 if(isImg && (srcset || isPicture)){
    451                                         updatePolyfill(elem, {src: src});
    452                                 }
    453                         }
    454 
    455                         if(elem._lazyRace){
    456                                 delete elem._lazyRace;
    457                         }
    458                         removeClass(elem, lazySizesConfig.lazyClass);
    459 
    460                         rAF(function(){
    461                                 if( !firesLoad || (elem.complete && elem.naturalWidth > 1)){
    462                                         if(firesLoad){
    463                                                 resetPreloading(event);
    464                                         } else {
    465                                                 isLoading--;
    466                                         }
    467                                         switchLoadingClass(event);
    468                                 }
    469                         }, true);
    470                 });
    471 
    472                 var unveilElement = function (elem){
    473                         var detail;
    474 
    475                         var isImg = regImg.test(elem.nodeName);
    476 
    477                         //allow using sizes="auto", but don't use. it's invalid. Use data-sizes="auto" or a valid value for sizes instead (i.e.: sizes="80vw")
    478                         var sizes = isImg && (elem[_getAttribute](lazySizesConfig.sizesAttr) || elem[_getAttribute]('sizes'));
    479                         var isAuto = sizes == 'auto';
    480 
    481                         if( (isAuto || !isCompleted) && isImg && (elem[_getAttribute]('src') || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesConfig.errorClass)){return;}
    482 
    483                         detail = triggerEvent(elem, 'lazyunveilread').detail;
    484 
    485                         if(isAuto){
    486                                  autoSizer.updateElem(elem, true, elem.offsetWidth);
    487                         }
    488 
    489                         elem._lazyRace = true;
    490                         isLoading++;
    491 
    492                         lazyUnveil(elem, detail, isAuto, sizes, isImg);
    493                 };
    494 
    495                 var onload = function(){
    496                         if(isCompleted){return;}
    497                         if(Date.now() - started < 999){
    498                                 setTimeout(onload, 999);
    499                                 return;
    500                         }
    501                         var afterScroll = debounce(function(){
    502                                 lazySizesConfig.loadMode = 3;
    503                                 throttledCheckElements();
    504                         });
    505 
    506                         isCompleted = true;
    507 
    508                         lazySizesConfig.loadMode = 3;
    509 
    510                         throttledCheckElements();
    511 
    512                         addEventListener('scroll', function(){
    513                                 if(lazySizesConfig.loadMode == 3){
    514                                         lazySizesConfig.loadMode = 2;
    515                                 }
    516                                 afterScroll();
    517                         }, true);
    518                 };
    519 
    520                 return {
    521                         _: function(){
    522                                 started = Date.now();
    523 
    524                                 lazysizes.elements = document.getElementsByClassName(lazySizesConfig.lazyClass);
    525                                 preloadElems = document.getElementsByClassName(lazySizesConfig.lazyClass + ' ' + lazySizesConfig.preloadClass);
    526                                 hFac = lazySizesConfig.hFac;
    527 
    528                                 addEventListener('scroll', throttledCheckElements, true);
    529 
    530                                 addEventListener('resize', throttledCheckElements, true);
    531 
    532                                 if(window.MutationObserver){
    533                                         new MutationObserver( throttledCheckElements ).observe( docElem, {childList: true, subtree: true, attributes: true} );
    534                                 } else {
    535                                         docElem[_addEventListener]('DOMNodeInserted', throttledCheckElements, true);
    536                                         docElem[_addEventListener]('DOMAttrModified', throttledCheckElements, true);
    537                                         setInterval(throttledCheckElements, 999);
    538                                 }
    539 
    540                                 addEventListener('hashchange', throttledCheckElements, true);
    541 
    542                                 //, 'fullscreenchange'
    543                                 ['focus', 'mouseover', 'click', 'load', 'transitionend', 'animationend', 'webkitAnimationEnd'].forEach(function(name){
    544                                         document[_addEventListener](name, throttledCheckElements, true);
    545                                 });
    546 
    547                                 if((/d$|^c/.test(document.readyState))){
    548                                         onload();
    549                                 } else {
    550                                         addEventListener('load', onload);
    551                                         document[_addEventListener]('DOMContentLoaded', throttledCheckElements);
    552                                         setTimeout(onload, 20000);
    553                                 }
    554 
    555                                 if(lazysizes.elements.length){
    556                                         checkElements();
    557                                         rAF._lsFlush();
    558                                 } else {
    559                                         throttledCheckElements();
    560                                 }
    561                         },
    562                         checkElems: throttledCheckElements,
    563                         unveil: unveilElement
    564                 };
    565         })();
    566 
    567 
    568         var autoSizer = (function(){
    569                 var autosizesElems;
    570 
    571                 var sizeElement = rAFIt(function(elem, parent, event, width){
    572                         var sources, i, len;
    573                         elem._lazysizesWidth = width;
    574                         width += 'px';
    575 
    576                         elem.setAttribute('sizes', width);
    577 
    578                         if(regPicture.test(parent.nodeName || '')){
    579                                 sources = parent.getElementsByTagName('source');
    580                                 for(i = 0, len = sources.length; i < len; i++){
    581                                         sources[i].setAttribute('sizes', width);
    582                                 }
    583                         }
    584 
    585                         if(!event.detail.dataAttr){
    586                                 updatePolyfill(elem, event.detail);
    587                         }
    588                 });
    589                 var getSizeElement = function (elem, dataAttr, width){
    590                         var event;
    591                         var parent = elem.parentNode;
    592 
    593                         if(parent){
    594                                 width = getWidth(elem, parent, width);
    595                                 event = triggerEvent(elem, 'lazybeforesizes', {width: width, dataAttr: !!dataAttr});
    596 
    597                                 if(!event.defaultPrevented){
    598                                         width = event.detail.width;
    599 
    600                                         if(width && width !== elem._lazysizesWidth){
    601                                                 sizeElement(elem, parent, event, width);
    602                                         }
    603                                 }
    604                         }
    605                 };
    606 
    607                 var updateElementsSizes = function(){
    608                         var i;
    609                         var len = autosizesElems.length;
    610                         if(len){
    611                                 i = 0;
    612 
    613                                 for(; i < len; i++){
    614                                         getSizeElement(autosizesElems[i]);
    615                                 }
    616                         }
    617                 };
    618 
    619                 var debouncedUpdateElementsSizes = debounce(updateElementsSizes);
    620 
    621                 return {
    622                         _: function(){
    623                                 autosizesElems = document.getElementsByClassName(lazySizesConfig.autosizesClass);
    624                                 addEventListener('resize', debouncedUpdateElementsSizes);
    625                         },
    626                         checkElems: debouncedUpdateElementsSizes,
    627                         updateElem: getSizeElement
    628                 };
    629         })();
    630 
    631         var init = function(){
    632                 if(!init.i){
    633                         init.i = true;
    634                         autoSizer._();
    635                         loader._();
    636                 }
    637238        };
    638239
     
    659260                        loadMode: 2,
    660261                        loadHidden: true,
     262                        ricTimeout: 0,
     263                        throttleDelay: 125,
    661264                };
    662265
     
    677280                });
    678281        })();
     282
     283        var loader = (function(){
     284                var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
     285
     286                var eLvW, elvH, eLtop, eLleft, eLright, eLbottom;
     287
     288                var defaultExpand, preloadExpand, hFac;
     289
     290                var regImg = /^img$/i;
     291                var regIframe = /^iframe$/i;
     292
     293                var supportScroll = ('onscroll' in window) && !(/glebot/.test(navigator.userAgent));
     294
     295                var shrinkExpand = 0;
     296                var currentExpand = 0;
     297
     298                var isLoading = 0;
     299                var lowRuns = -1;
     300
     301                var resetPreloading = function(e){
     302                        isLoading--;
     303                        if(e && e.target){
     304                                addRemoveLoadEvents(e.target, resetPreloading);
     305                        }
     306
     307                        if(!e || isLoading < 0 || !e.target){
     308                                isLoading = 0;
     309                        }
     310                };
     311
     312                var isNestedVisible = function(elem, elemExpand){
     313                        var outerRect;
     314                        var parent = elem;
     315                        var visible = getCSS(document.body, 'visibility') == 'hidden' || getCSS(elem, 'visibility') != 'hidden';
     316
     317                        eLtop -= elemExpand;
     318                        eLbottom += elemExpand;
     319                        eLleft -= elemExpand;
     320                        eLright += elemExpand;
     321
     322                        while(visible && (parent = parent.offsetParent) && parent != document.body && parent != docElem){
     323                                visible = ((getCSS(parent, 'opacity') || 1) > 0);
     324
     325                                if(visible && getCSS(parent, 'overflow') != 'visible'){
     326                                        outerRect = parent.getBoundingClientRect();
     327                                        visible = eLright > outerRect.left &&
     328                                                eLleft < outerRect.right &&
     329                                                eLbottom > outerRect.top - 1 &&
     330                                                eLtop < outerRect.bottom + 1
     331                                        ;
     332                                }
     333                        }
     334
     335                        return visible;
     336                };
     337
     338                var checkElements = function() {
     339                        var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal, beforeExpandVal;
     340
     341                        var lazyloadElems = lazysizes.elements;
     342
     343                        if((loadMode = lazySizesConfig.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)){
     344
     345                                i = 0;
     346
     347                                lowRuns++;
     348
     349                                if(preloadExpand == null){
     350                                        if(!('expand' in lazySizesConfig)){
     351                                                lazySizesConfig.expand = docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370;
     352                                        }
     353
     354                                        defaultExpand = lazySizesConfig.expand;
     355                                        preloadExpand = defaultExpand * lazySizesConfig.expFactor;
     356                                }
     357
     358                                if(currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document.hidden){
     359                                        currentExpand = preloadExpand;
     360                                        lowRuns = 0;
     361                                } else if(loadMode > 1 && lowRuns > 1 && isLoading < 6){
     362                                        currentExpand = defaultExpand;
     363                                } else {
     364                                        currentExpand = shrinkExpand;
     365                                }
     366
     367                                for(; i < eLlen; i++){
     368
     369                                        if(!lazyloadElems[i] || lazyloadElems[i]._lazyRace){continue;}
     370
     371                                        if(!supportScroll){unveilElement(lazyloadElems[i]);continue;}
     372
     373                                        if(!(elemExpandVal = lazyloadElems[i][_getAttribute]('data-expand')) || !(elemExpand = elemExpandVal * 1)){
     374                                                elemExpand = currentExpand;
     375                                        }
     376
     377                                        if(beforeExpandVal !== elemExpand){
     378                                                eLvW = innerWidth + (elemExpand * hFac);
     379                                                elvH = innerHeight + elemExpand;
     380                                                elemNegativeExpand = elemExpand * -1;
     381                                                beforeExpandVal = elemExpand;
     382                                        }
     383
     384                                        rect = lazyloadElems[i].getBoundingClientRect();
     385
     386                                        if ((eLbottom = rect.bottom) >= elemNegativeExpand &&
     387                                                (eLtop = rect.top) <= elvH &&
     388                                                (eLright = rect.right) >= elemNegativeExpand * hFac &&
     389                                                (eLleft = rect.left) <= eLvW &&
     390                                                (eLbottom || eLright || eLleft || eLtop) &&
     391                                                (lazySizesConfig.loadHidden || getCSS(lazyloadElems[i], 'visibility') != 'hidden') &&
     392                                                ((isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4)) || isNestedVisible(lazyloadElems[i], elemExpand))){
     393                                                unveilElement(lazyloadElems[i]);
     394                                                loadedSomething = true;
     395                                                if(isLoading > 9){break;}
     396                                        } else if(!loadedSomething && isCompleted && !autoLoadElem &&
     397                                                isLoading < 4 && lowRuns < 4 && loadMode > 2 &&
     398                                                (preloadElems[0] || lazySizesConfig.preloadAfterLoad) &&
     399                                                (preloadElems[0] || (!elemExpandVal && ((eLbottom || eLright || eLleft || eLtop) || lazyloadElems[i][_getAttribute](lazySizesConfig.sizesAttr) != 'auto')))){
     400                                                autoLoadElem = preloadElems[0] || lazyloadElems[i];
     401                                        }
     402                                }
     403
     404                                if(autoLoadElem && !loadedSomething){
     405                                        unveilElement(autoLoadElem);
     406                                }
     407                        }
     408                };
     409
     410                var throttledCheckElements = throttle(checkElements);
     411
     412                var switchLoadingClass = function(e){
     413                        addClass(e.target, lazySizesConfig.loadedClass);
     414                        removeClass(e.target, lazySizesConfig.loadingClass);
     415                        addRemoveLoadEvents(e.target, rafSwitchLoadingClass);
     416                        triggerEvent(e.target, 'lazyloaded');
     417                };
     418                var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
     419                var rafSwitchLoadingClass = function(e){
     420                        rafedSwitchLoadingClass({target: e.target});
     421                };
     422
     423                var changeIframeSrc = function(elem, src){
     424                        try {
     425                                elem.contentWindow.location.replace(src);
     426                        } catch(e){
     427                                elem.src = src;
     428                        }
     429                };
     430
     431                var handleSources = function(source){
     432                        var customMedia;
     433
     434                        var sourceSrcset = source[_getAttribute](lazySizesConfig.srcsetAttr);
     435
     436                        if( (customMedia = lazySizesConfig.customMedia[source[_getAttribute]('data-media') || source[_getAttribute]('media')]) ){
     437                                source.setAttribute('media', customMedia);
     438                        }
     439
     440                        if(sourceSrcset){
     441                                source.setAttribute('srcset', sourceSrcset);
     442                        }
     443                };
     444
     445                var lazyUnveil = rAFIt(function (elem, detail, isAuto, sizes, isImg){
     446                        var src, srcset, parent, isPicture, event, firesLoad;
     447
     448                        if(!(event = triggerEvent(elem, 'lazybeforeunveil', detail)).defaultPrevented){
     449
     450                                if(sizes){
     451                                        if(isAuto){
     452                                                addClass(elem, lazySizesConfig.autosizesClass);
     453                                        } else {
     454                                                elem.setAttribute('sizes', sizes);
     455                                        }
     456                                }
     457
     458                                srcset = elem[_getAttribute](lazySizesConfig.srcsetAttr);
     459                                src = elem[_getAttribute](lazySizesConfig.srcAttr);
     460
     461                                if(isImg) {
     462                                        parent = elem.parentNode;
     463                                        isPicture = parent && regPicture.test(parent.nodeName || '');
     464                                }
     465
     466                                firesLoad = detail.firesLoad || (('src' in elem) && (srcset || src || isPicture));
     467
     468                                event = {target: elem};
     469
     470                                if(firesLoad){
     471                                        addRemoveLoadEvents(elem, resetPreloading, true);
     472                                        clearTimeout(resetPreloadingTimer);
     473                                        resetPreloadingTimer = setTimeout(resetPreloading, 2500);
     474
     475                                        addClass(elem, lazySizesConfig.loadingClass);
     476                                        addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
     477                                }
     478
     479                                if(isPicture){
     480                                        forEach.call(parent.getElementsByTagName('source'), handleSources);
     481                                }
     482
     483                                if(srcset){
     484                                        elem.setAttribute('srcset', srcset);
     485                                } else if(src && !isPicture){
     486                                        if(regIframe.test(elem.nodeName)){
     487                                                changeIframeSrc(elem, src);
     488                                        } else {
     489                                                elem.src = src;
     490                                        }
     491                                }
     492
     493                                if(isImg && (srcset || isPicture)){
     494                                        updatePolyfill(elem, {src: src});
     495                                }
     496                        }
     497
     498                        if(elem._lazyRace){
     499                                delete elem._lazyRace;
     500                        }
     501                        removeClass(elem, lazySizesConfig.lazyClass);
     502
     503                        rAF(function(){
     504                                if( !firesLoad || (elem.complete && elem.naturalWidth > 1)){
     505                                        if(firesLoad){
     506                                                resetPreloading(event);
     507                                        } else {
     508                                                isLoading--;
     509                                        }
     510                                        switchLoadingClass(event);
     511                                }
     512                        }, true);
     513                });
     514
     515                var unveilElement = function (elem){
     516                        var detail;
     517
     518                        var isImg = regImg.test(elem.nodeName);
     519
     520                        //allow using sizes="auto", but don't use. it's invalid. Use data-sizes="auto" or a valid value for sizes instead (i.e.: sizes="80vw")
     521                        var sizes = isImg && (elem[_getAttribute](lazySizesConfig.sizesAttr) || elem[_getAttribute]('sizes'));
     522                        var isAuto = sizes == 'auto';
     523
     524                        if( (isAuto || !isCompleted) && isImg && (elem[_getAttribute]('src') || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesConfig.errorClass) && hasClass(elem, lazySizesConfig.lazyClass)){return;}
     525
     526                        detail = triggerEvent(elem, 'lazyunveilread').detail;
     527
     528                        if(isAuto){
     529                                 autoSizer.updateElem(elem, true, elem.offsetWidth);
     530                        }
     531
     532                        elem._lazyRace = true;
     533                        isLoading++;
     534
     535                        lazyUnveil(elem, detail, isAuto, sizes, isImg);
     536                };
     537
     538                var onload = function(){
     539                        if(isCompleted){return;}
     540                        if(Date.now() - started < 999){
     541                                setTimeout(onload, 999);
     542                                return;
     543                        }
     544                        var afterScroll = debounce(function(){
     545                                lazySizesConfig.loadMode = 3;
     546                                throttledCheckElements();
     547                        });
     548
     549                        isCompleted = true;
     550
     551                        lazySizesConfig.loadMode = 3;
     552
     553                        throttledCheckElements();
     554
     555                        addEventListener('scroll', function(){
     556                                if(lazySizesConfig.loadMode == 3){
     557                                        lazySizesConfig.loadMode = 2;
     558                                }
     559                                afterScroll();
     560                        }, true);
     561                };
     562
     563                return {
     564                        _: function(){
     565                                started = Date.now();
     566
     567                                lazysizes.elements = document.getElementsByClassName(lazySizesConfig.lazyClass);
     568                                preloadElems = document.getElementsByClassName(lazySizesConfig.lazyClass + ' ' + lazySizesConfig.preloadClass);
     569                                hFac = lazySizesConfig.hFac;
     570
     571                                addEventListener('scroll', throttledCheckElements, true);
     572
     573                                addEventListener('resize', throttledCheckElements, true);
     574
     575                                if(window.MutationObserver){
     576                                        new MutationObserver( throttledCheckElements ).observe( docElem, {childList: true, subtree: true, attributes: true} );
     577                                } else {
     578                                        docElem[_addEventListener]('DOMNodeInserted', throttledCheckElements, true);
     579                                        docElem[_addEventListener]('DOMAttrModified', throttledCheckElements, true);
     580                                        setInterval(throttledCheckElements, 999);
     581                                }
     582
     583                                addEventListener('hashchange', throttledCheckElements, true);
     584
     585                                //, 'fullscreenchange'
     586                                ['focus', 'mouseover', 'click', 'load', 'transitionend', 'animationend', 'webkitAnimationEnd'].forEach(function(name){
     587                                        document[_addEventListener](name, throttledCheckElements, true);
     588                                });
     589
     590                                if((/d$|^c/.test(document.readyState))){
     591                                        onload();
     592                                } else {
     593                                        addEventListener('load', onload);
     594                                        document[_addEventListener]('DOMContentLoaded', throttledCheckElements);
     595                                        setTimeout(onload, 20000);
     596                                }
     597
     598                                if(lazysizes.elements.length){
     599                                        checkElements();
     600                                        rAF._lsFlush();
     601                                } else {
     602                                        throttledCheckElements();
     603                                }
     604                        },
     605                        checkElems: throttledCheckElements,
     606                        unveil: unveilElement
     607                };
     608        })();
     609
     610
     611        var autoSizer = (function(){
     612                var autosizesElems;
     613
     614                var sizeElement = rAFIt(function(elem, parent, event, width){
     615                        var sources, i, len;
     616                        elem._lazysizesWidth = width;
     617                        width += 'px';
     618
     619                        elem.setAttribute('sizes', width);
     620
     621                        if(regPicture.test(parent.nodeName || '')){
     622                                sources = parent.getElementsByTagName('source');
     623                                for(i = 0, len = sources.length; i < len; i++){
     624                                        sources[i].setAttribute('sizes', width);
     625                                }
     626                        }
     627
     628                        if(!event.detail.dataAttr){
     629                                updatePolyfill(elem, event.detail);
     630                        }
     631                });
     632                var getSizeElement = function (elem, dataAttr, width){
     633                        var event;
     634                        var parent = elem.parentNode;
     635
     636                        if(parent){
     637                                width = getWidth(elem, parent, width);
     638                                event = triggerEvent(elem, 'lazybeforesizes', {width: width, dataAttr: !!dataAttr});
     639
     640                                if(!event.defaultPrevented){
     641                                        width = event.detail.width;
     642
     643                                        if(width && width !== elem._lazysizesWidth){
     644                                                sizeElement(elem, parent, event, width);
     645                                        }
     646                                }
     647                        }
     648                };
     649
     650                var updateElementsSizes = function(){
     651                        var i;
     652                        var len = autosizesElems.length;
     653                        if(len){
     654                                i = 0;
     655
     656                                for(; i < len; i++){
     657                                        getSizeElement(autosizesElems[i]);
     658                                }
     659                        }
     660                };
     661
     662                var debouncedUpdateElementsSizes = debounce(updateElementsSizes);
     663
     664                return {
     665                        _: function(){
     666                                autosizesElems = document.getElementsByClassName(lazySizesConfig.autosizesClass);
     667                                addEventListener('resize', debouncedUpdateElementsSizes);
     668                        },
     669                        checkElems: debouncedUpdateElementsSizes,
     670                        updateElem: getSizeElement
     671                };
     672        })();
     673
     674        var init = function(){
     675                if(!init.i){
     676                        init.i = true;
     677                        autoSizer._();
     678                        loader._();
     679                }
     680        };
    679681
    680682        lazysizes = {
  • _plugins_/lazysizes/trunk/lazysizes_config.js.html

    r105556 r110469  
    1 #HTTP_HEADER{Content-Type: text/javascript}
     1[(#HTTP_HEADER{Content-Type: text/javascript; charset=#CHARSET})][
     2(#REM)<!--
    23
    3 [(#SET{options, #CONFIG{lazysizes/options}})]
    4 window.lazySizesConfig = window.lazySizesConfig || {};
    5 [window.lazySizesConfig.lazyClass = '(#GET{options/lazy_class})';]
    6 [window.lazySizesConfig.preloadClass = '(#GET{options/preload_class})';]
    7 [window.lazySizesConfig.loadingClass = '(#GET{options/loading_class})';]
    8 [window.lazySizesConfig.srcAttr = '(#GET{options/src_attr})';]
    9 [window.lazySizesConfig.sizesAttr = '(#GET{options/sizes_attr})';]
    10 [window.lazySizesConfig.srcsetAttr = '(#GET{options/srcset_attr})';]
     4-->][
     5(#SET{options, #CONFIG{lazysizes/options}})]
     6window.lazySizesConfig = window.lazySizesConfig || {};[
     7window.lazySizesConfig.lazyClass = '(#GET{options/lazy_class})';][
     8window.lazySizesConfig.preloadClass = '(#GET{options/preload_class})';][
     9window.lazySizesConfig.loadingClass = '(#GET{options/loading_class})';][
     10window.lazySizesConfig.srcAttr = '(#GET{options/src_attr})';][
     11window.lazySizesConfig.sizesAttr = '(#GET{options/sizes_attr})';][
     12window.lazySizesConfig.srcsetAttr = '(#GET{options/srcset_attr})';][
     13(#REM)<!--
    1114//page is optimized for fast onload event
    1215//lazySizesConfig.loadMode = 1;
    1316
    1417//console.log(lazySizesConfig);
    15 
     18 DEFAULT-->]
    1619window.lazySizesConfig.init = false;
  • _plugins_/lazysizes/trunk/paquet.xml

    r106783 r110469  
    22        prefix="lazysizes"
    33        categorie="outil"
    4         version="4.0.0.14"
     4        version="4.0.2.1"
    55        etat="dev"
    66        compatibilite="[3.0.0;3.2.*]"
     
    99>
    1010        <nom>LazySizes</nom>
    11        
     11
    1212        <auteur lien="http://www.mister-graphx.com">Arnaud B. (Mist. GraphX)</auteur>
    1313        <credit lien="https://github.com/aFarkas/lazysizes">Lazysizes</credit>
    14                    
     14
    1515        <licence>GNU/GPL</licence>
    16        
     16
    1717        <pipeline nom="insert_head_css" action="insert_head_css" inclure="lazysizes_pipelines.php" />
    1818        <pipeline nom="insert_head" action="insert_head_public" inclure="lazysizes_pipelines.php" />
    1919        <pipeline nom="header_prive" inclure="lazysizes_pipelines.php" />
    2020        <pipeline nom="ieconfig_metas" inclure="lazysizes_pipelines.php" />
    21        
     21
    2222        <necessite nom="htmlpurifier" compatibilite="[4.9.2.0;]" />
    2323        <utilise nom="medias" compatibilite="[2.10.38;]" />
    24        
     24
    2525</paquet>
Note: See TracChangeset for help on using the changeset viewer.