npm package: @impactdk/ngx-lazyload
Description: A module to easily add lazyloading of images and picture tags in your Angular application
Author: Martin Hobert
Latest version: 2.0.0-rc.1

# ngx-lazyload

A module to easily add lazyloading of images and picture tags in your Angular application

## Versions

- Angular 8+ - Use ^2.0.0
- Angular versions lower than 8 - Use ^1.0.0

## Installation

Import the NgxLazyloadModule from `@impactdk/ngx-lazyload` in the module you want to use the directive / LazyPicture component in. If you wish you can add configs in the forRoot/forFeature method on the module.

Note: You need to provide the ObserverService from `@impactdk/ngx-lazyload` in your app.module unless you are using `.forFeature()`

```typescript
import { NgModule } from '@angular/core';
import { AppComponent } from './app.component';
import { BrowserModule } from '@angular/platform-browser';

import { NgxLazyloadModule, ObserverService } from '@impact/ngx-lazyload';

@NgModule({
    imports: [BrowserModule, NgxLazyloadModule],
    declarations: [AppComponent],
    bootstrap: [AppComponent],
})
export class AppModule {}
```

```typescript
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';

import { NgxLazyloadModule, ObserverService } from '@impact/ngx-lazyload';

@NgModule({
    imports: [BrowserModule, NgxLazyloadModule.forFeature()], // Optionally provide a config like this: { rootMargin: '200px', threshold: 0.1 }
})
export class FeatureModule {}
```

The config has a few options:

```typescript
interface ObserverServiceConfig {
    root?: Element | null;
    rootMargin?: string;
    threshold?: number | number[];
}
```

`root`:
The element that is used as the viewport for checking visiblity of the target. Must be the ancestor of the target. Defaults to the browser viewport if not specified or if null.

`rootMargin`:
Margin around the root. Can have values similar to the CSS margin property, e.g. "10px 20px 30px 40px" (top, right, bottom, left). If the root element is specified, the values can be percentages. This set of values serves to grow or shrink each side of the root element's bounding box before computing intersections. Defaults to all zeros.

`threshold`:
Either a single number or an array of numbers which indicate at what percentage of the target's visibility the observer's callback should be executed. If you only want to detect when visibility passes the 50% mark, you can use a value of 0.5. If you want the callback run every time visibility passes another 25%, you would specify the array [0, 0.25, 0.5, 0.75, 1]. The default is 0 (meaning as soon as even one pixel is visible, the callback will be run). A value of 1.0 means that the threshold isn't considered passed until every pixel is visible.

## Usage

This module provides lazy loading for 2 use cases, a normal `img` tag and a component to generate `picture` tags with lazy loading of sources.

### The `img` tag

We have created a LazeLoad directive that you can apply to any `img` tag. It has two inputs `LazyLoadSrc` and `LazyLoadSrcSet` (Optional).

**Usage:**

```html
<img
    Lazyload
    [LazyLoadSrc]="src"
    [LazyLoadSrcSet]="srcSet"
    alt="A fancy image"
/>
```

### The picture component

We have also created a component to generate lazy loaded `picture` tags with sources within. To use it simply add the `LazyPicture` component and supply the inputs 5 inputs:

-   LazyLoadSrc - The source of the default image
-   LazyLoadAlt - The alt tag of the image (Optional)
-   LazyLoadSources - An array of sources (Optional)
-   LazyImageWidth - The width of the image (Optional)
-   LazyImageHeight - The height of the image (Optional)

The sources should have the following format:

```typescript
interface LazyLoadSource {
    media?: string; // "(max-width: 700px)"
    srcSet?: string; // "stick-figure-narrow.png 138w, stick-figure-hd-narrow.png 138w"
    sizes?: string; // "(max-width: 500px) 50vw, 10vw"
}
```

**Useage:**

```html
<LazyPicture
    *ngFor="let picture of pictures"
    [LazyLoadSrc]="picture.src"
    [LazyLoadAlt]="picture.alt"
    [LazyLoadSources]="picture.sources"
    [LazyImageWidth]="picture.width"
    [LazyImageHeight]="picture.height"
>
</LazyPicture>
```

## SSR Support

The module does support Server side rendering, however by default it will simply apply the sources on the server rendering.

This ofcourse means that any pictures that should have been lazy loaded, will on the first request not be and have all the sources set in place.

It is however possible to fix this by injecting a boolean called "isBot" in your application, if its false it will not apply the sources on the server, if its true it will assume that its a crawler or bot from a search engine or social media that should be provided with the image, and apply the sources right away.

We recommend that you use [isBot](https://github.com/gorangajic/isbot) and inject it in your Express server like this:

```typescript
const isBot = require('isbot');

const {
    provideModuleMap,
} = require('@nguniversal/module-map-ngfactory-loader');
app.engine('html', (_, options, callback) => {
    const isCrawler = isBot(options.req.headers['user-agent']);
    renderModuleFactory(AppServerModuleNgFactory, {
        // Our index.html
        document: template,
        url: options.req.url,
        // DI so that we can get lazy-loading to work differently (since we need it to just instantly render it)
        extraProviders: [
            provideModuleMap(LAZY_MODULE_MAP),
            {
                provide: 'isBot',
                useFactory: () => isCrawler,
                deps: [],
            },
        ],
    }).then(html => {
        callback(null, html);
    });
});
```

## Further help

Reach out to [MHO](mailto:mho@impact.dk) (Martin Hobert)