yall.js is a SEO-friendly lazy loader for elements as well as CSS background images. It works in all modern browsers. It uses Intersection Observer where available. yall.js can also monitor the DOM for changes using Mutation Observer to lazy load elements that have been appended to the DOM after initial load, which may be desirable for single page applications.
yall.js 4 removes lazy loading for , , and elements, as native lazy loading covers these use cases. However, yall.js 4 retains the ability to lazy load autoplaying (ala animated GIFs), lazy loading element poster images, as well as CSS background images.
To use yall, grab yall.min.js (or yall.min.mjs if you're the modern sort) from the dist directory and slap it on your page. You can also install it with npm:
``shell npm install yall-js `
Usage
This is version 4 of yall.js, and introduces a named export named yall rather than a single default export:
`javascript // Import y'all import { yall } from "yall-js";
// Invoke! yall(); `
The above syntax is sufficient if you don't want to pass in any options. If you _do_ want to specify options, you'll need to use a slightly more verbose syntax:
`javascript // Import y'all import { yall } from "yall-js";
// Invoke! yall({ observeChanges: true }); `
From there, lazy loading elements depends on _what_ you want to lazy load. Let's take a look at what you can do with it.
$3
yall.js covers two possible lazy loading patterns for video.
#### Lazy-loading videos intended as replacements for animated GIFs
yall.js can lazy load
`html
`
The pattern is largely the same as it is with , only the lazy class is applied to the
#### Lazy-loading poster placeholder images for non-autoplaying video
Sometimes you have video you'd rather not autoplay, such as those with an audio track. Or, perhaps you want to be more considerate of your user's bandwidth (how nice of you). In these cases, the poster attribute can be used to load a placeholder image. However, these images can also be rather large, especially if you have a number of videos on the page that use this pattern. You can lazy load poster images with the following markup pattern:
`html
`
This pattern is slightly different than the one before it. Because we're not trying to emulate animated GIFs, we've removed a number of attributes from the
1. We've done away with the usual data-src attribute, and specified preload="none" to ensure the browser doesn't preload any portion of the video (which, depending on the browser, can't be guaranteed). 2. To lazy load the poster image itself, we specify the image to load in a data-poster attribute. 3. The controls attribute is added here to allow the user to control video playback.
Note: For the sake of your users, don't mix the above markup patterns. If a video is going to use autoplay to replace an animated image, lazy loading a placeholder image via data-poster isn't necessary. Furthermore, if you're unsure of what to do, _let browsers handle this stuff and don't use yall.js to manage loading of videos at all!_
$3
Last, but not least, you can use yall.js to lazy load images referenced in CSS. This might be useful if you have a very large background-image you'd like to defer. Proper use of this feature requires _both_ HTML and CSS. To start, let's say you have a
that loads a very large masthead background-image:`html
`
The key here is the
lazy-bg class, which is a class yall.js looks for (and can be changed in the options). When yall.js sees elements with this class, it will remove that class and replace it with a class of lazy-bg-loaded (also changeable in the options). From here, it's up to you to author CSS that makes use of this class to swap the image in. Such CSS might look like this:`css / Pre-lazy loading styles / .masthead { background: #e6e6e6; / A little placeholder color / height: 16.66vw; margin: 0 0 1rem; }
This works because, unlike HTML which loads most resources regardless of their visibility, CSS loads resources only if the current layout builds a CSSOM which includes them. That means if your document's style tree changes later on to request a background image, the browser will fetch it the moment the change is applied. Leaning on this behavior is more sensible than using a mess of
data- attributes pointing to possible image candidates, which could potentially add a bunch of extra markup and introduce edge cases that are difficult to code for.