@bespunky/angular-zen
Version:
The Angular tools you always wished were there.
162 lines • 26.1 kB
JavaScript
import { Observable, of } from 'rxjs';
import { Injectable } from '@angular/core';
import { HeadService } from '@bespunky/angular-zen/core';
import { UniversalService } from '@bespunky/angular-zen/universal';
import * as i0 from "@angular/core";
import * as i1 from "@bespunky/angular-zen/core";
import * as i2 from "@bespunky/angular-zen/universal";
/**
* Provides methods for lazy loading scripts and styles programatically.
* The service keeps track of loaded files to skip reloading unless specified otherwise in the options of `loadScript()` or `loadStyle()`.
*/
export class LazyLoaderService {
constructor(head, universal) {
this.head = head;
this.universal = universal;
/**
* Defines the default options when calling the `LazyLoaderService.loadScript()` method.
*/
this.defaultScriptOptions = {
async: true,
defer: true,
alreadyLoaded: (url) => this.isCached(url) || this.isScriptPresent(url),
force: false
};
/**
* Defines the default options when calling the `LazyLoaderService.loadStyle()` method.
*/
this.defaultStyleOptions = {
alreadyLoaded: (url) => this.isCached(url) || this.isStylePresent(url),
force: false
};
this.cache = {};
}
/**
* Checks whether the file from the specified url has already been cached.
* @param url The url for the file to check.
* @returns A value indicating whether the file from the specified url has already been cached.
*/
isCached(url) {
return !!this.cache[url];
}
/**
* Checks whether a script element is already present in `<head>` for the given url.
* This doesn't guarantee that the script has been loaded.
*
* @param {string} url The url of the loaded script.
* @returns {boolean} `true` if an element matching the url is present in `<head>`; otherwise `false.
*/
isScriptPresent(url) {
return this.head.contains('script', { src: url });
}
/**
* Checks whether a link element is already present in `<head>` for the given style url.
* This doesn't guarantee that the style has been loaded.
*
* @param {string} url The url of the loaded link.
* @returns {boolean} `true` if an element matching the url is present in `<head>`; otherwise `false.
*/
isStylePresent(url) {
return this.head.contains('link', { rel: 'stylesheet', href: url });
}
/**
* Loads a script programatically.
*
* @param url The full url of the script to load.
* @param options (Optional) Specifies custom options to override default behaviour.
* @returns An observable object which allows subscribers to know when the script has been loaded and access its associated `<script>` element.
* The observable will complete immediately in case the script was already previously loaded.
* If the script was already loaded outside of the service, the observable will stream `undefined`.
*/
loadScript(url, options = this.defaultScriptOptions) {
// Set default options if not specified by caller
options.async = options.async === undefined ? this.defaultScriptOptions.async : options.async;
options.defer = options.defer === undefined ? this.defaultScriptOptions.defer : options.defer;
options.alreadyLoaded = options.alreadyLoaded === undefined ? this.defaultScriptOptions.alreadyLoaded : options.alreadyLoaded;
options.force = options.force === undefined ? this.defaultScriptOptions.force : options.force;
return this.loadFile(url, 'script', options, this.createScriptElement.bind(this));
}
/**
* Loads a style programatically.
*
* @param url The full url of the style to load.
* @param options (Optional) Specifies custom options to override default behaviour.
* @returns An observable object which allows subscribers to know when the style has been loaded and access its associated `<link>` element.
* The observable will complete immediately in case the style was already previously loaded.
* If the style was already loaded outside of the service, the observable will stream `undefined`.
*/
loadStyle(url, options = this.defaultStyleOptions) {
// Set default options if not specified by caller
options.alreadyLoaded = options.alreadyLoaded === undefined ? this.defaultStyleOptions.alreadyLoaded : options.alreadyLoaded;
options.force = options.force === undefined ? this.defaultStyleOptions.force : options.force;
return this.loadFile(url, 'style', options, this.createLinkElement.bind(this));
}
loadFile(url, type, options, createElement) {
if (!this.universal.isPlatformBrowser)
return of(null);
// If the script should be loaded, load it
if (!options.alreadyLoaded(url) || options.force) {
// Initialize a base object to store the data later
const lazyFile = { url, type, completed: false, element: null };
// Create an observable that waits until the script has been loaded and executed
const observable = new Observable(observer => {
// Create the callback that will mark the script as completed and notify the subscriber
const onLoad = () => {
lazyFile.completed = true;
observer.next(lazyFile);
observer.complete();
};
// Create the actual file tag, start downloading and store the element reference
lazyFile.element = createElement(url, onLoad, observer.error.bind(observer), options);
});
// Cache the file and the observable for later use
this.cache[url] = { lazyFile: lazyFile, observable };
return observable;
}
// If the file was already loaded and it shouldn't be downloaded again, complete immediately with the previous link data.
// If the file was already loaded outside of the service, the observable will stream `undefined` as there is nothing cached.
return of(this.cache[url]?.lazyFile);
}
/**
* Creates a `<script>` tag for the given url and adds it to the `<head>` tag to start downloading the script.
*
* @param url The url for the script to download.
* @param onLoad The callback to execute when the script has been downloaded and executed.
* @param onError The callback to execute when script download or execution has failed.
* @param options The options to add to the script.
* @returns A reference to the `<script>` element that was added to the DOM.
*/
createScriptElement(url, onLoad, onError, options) {
return this.head.addScriptElement('text/javascript', url, {
async: options.async,
defer: options.defer,
onload: onLoad,
onerror: onError
});
}
/**
* Creates a `<link>` tag for the given url and adds it to the `<head>` tag to start downloading the link.
*
* @param url The url for the link to download.
* @param onLoad The callback to execute when the script has been downloaded and executed.
* @param onError The callback to execute when script download or execution has failed.
* @returns A reference to the `<link>` element that was added to the DOM.
*/
createLinkElement(url, onLoad, onError) {
return this.head.addLinkElement('stylesheet', {
type: 'text/css',
href: url,
onload: onLoad,
onerror: onError
});
}
}
LazyLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LazyLoaderService, deps: [{ token: i1.HeadService }, { token: i2.UniversalService }], target: i0.ɵɵFactoryTarget.Injectable });
LazyLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LazyLoaderService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: LazyLoaderService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: function () { return [{ type: i1.HeadService }, { type: i2.UniversalService }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lazy-loader.service.js","sourceRoot":"","sources":["../../../../../../libs/angular-zen/async/src/lazy-loader/lazy-loader.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,UAAU,EAAc,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,WAAW,EAAQ,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAG,MAAM,iCAAiC,CAAC;;;;AAOpE;;;GAGG;AAIH,MAAM,OAAO,iBAAiB;IAyB1B,YAAoB,IAAiB,EAAU,SAA2B;QAAtD,SAAI,GAAJ,IAAI,CAAa;QAAU,cAAS,GAAT,SAAS,CAAkB;QAvB1E;;WAEG;QACK,yBAAoB,GAAsB;YAC9C,KAAK,EAAE,IAAI;YACX,KAAK,EAAE,IAAI;YACX,aAAa,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC;YACvE,KAAK,EAAE,KAAK;SACf,CAAC;QAED;;UAEE;QACK,wBAAmB,GAAgB;YACvC,aAAa,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;YACtE,KAAK,EAAE,KAAK;SACf,CAAC;QASE,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,GAAW;QAEvB,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IAED;;;;;;OAMG;IACI,eAAe,CAAC,GAAW;QAE9B,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;;;;;OAMG;IACI,cAAc,CAAC,GAAW;QAE7B,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;IACxE,CAAC;IAED;;;;;;;;OAQG;IACI,UAAU,CAAC,GAAW,EAAE,UAA6B,IAAI,CAAC,oBAAoB;QAEjF,iDAAiD;QACjD,OAAO,CAAC,KAAK,GAAW,OAAO,CAAC,KAAK,KAAa,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAC9G,OAAO,CAAC,KAAK,GAAW,OAAO,CAAC,KAAK,KAAa,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAC9G,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;QAC9H,OAAO,CAAC,KAAK,GAAW,OAAO,CAAC,KAAK,KAAa,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAE9G,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAsC,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACrH,CAAC;IAED;;;;;;;;OAQG;IACI,SAAS,CAAC,GAAW,EAAE,UAAuB,IAAI,CAAC,mBAAmB;QAEzE,iDAAiD;QACjD,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;QAC7H,OAAO,CAAC,KAAK,GAAW,OAAO,CAAC,KAAK,KAAa,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAE7G,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,OAAgC,EAAE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5G,CAAC;IAEO,QAAQ,CAAC,GAAW,EAAE,IAAwB,EAAE,OAA8B,EAAE,aAA6B;QAEjH,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,iBAAiB;YAAE,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAEvD,0CAA0C;QAC1C,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,KAAK,EAChD;YACI,mDAAmD;YACnD,MAAM,QAAQ,GAAmB,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAChF,gFAAgF;YAChF,MAAM,UAAU,GAAG,IAAI,UAAU,CAAiB,QAAQ,CAAC,EAAE;gBAEzD,uFAAuF;gBACvF,MAAM,MAAM,GAAG,GAAG,EAAE;oBAEhB,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC;oBAE1B,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBACxB,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBACxB,CAAC,CAAC;gBAEF,gFAAgF;gBAChF,QAAQ,CAAC,OAAO,GAAG,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC;YAC1F,CAAC,CAAC,CAAC;YAEH,kDAAkD;YAClD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;YAErD,OAAO,UAAU,CAAC;SACrB;QAED,yHAAyH;QACzH,4HAA4H;QAC5H,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;OAQG;IACK,mBAAmB,CAAC,GAAW,EAAE,MAAkB,EAAE,OAA6B,EAAE,OAA0B;QAElH,OAAO,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,GAAG,EACpD;YACI,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,OAAO;SACnB,CAAC,CAAC;IACX,CAAC;IAED;;;;;;;OAOG;IACK,iBAAiB,CAAC,GAAW,EAAE,MAAkB,EAAE,OAA6B;QAEpF,OAAO,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,YAAY,EACxC;YACI,IAAI,EAAE,UAAU;YAChB,IAAI,EAAE,GAAG;YACT,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,OAAO;SACnB,CAAC,CAAC;IACX,CAAC;;+GA/KQ,iBAAiB;mHAAjB,iBAAiB,cAFd,MAAM;4FAET,iBAAiB;kBAH7B,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Observable, of } from 'rxjs';\nimport { Injectable, ElementRef } from '@angular/core';\n\nimport { HeadService       } from '@bespunky/angular-zen/core';\nimport { UniversalService  } from '@bespunky/angular-zen/universal';\nimport { ScriptLoadOptions } from './script-load-options';\nimport { LoadOptions       } from './load-options';\nimport { LazyLoadedFile    } from './lazy-loaded-file';\n\ntype ElementCreator = (url: string, onLoad: () => void, onError: (error: any) => void, options: LoadOptions) => ElementRef;\n\n/**\n * Provides methods for lazy loading scripts and styles programatically.\n * The service keeps track of loaded files to skip reloading unless specified otherwise in the options of `loadScript()` or `loadStyle()`.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class LazyLoaderService\n{\n    /**\n     * Defines the default options when calling the `LazyLoaderService.loadScript()` method.\n     */\n    private defaultScriptOptions: ScriptLoadOptions = {\n        async: true,\n        defer: true,\n        alreadyLoaded: (url) => this.isCached(url) || this.isScriptPresent(url),\n        force: false\n    };\n\n     /**\n     * Defines the default options when calling the `LazyLoaderService.loadStyle()` method.\n     */\n    private defaultStyleOptions: LoadOptions = {\n        alreadyLoaded: (url) => this.isCached(url) || this.isStylePresent(url),\n        force: false\n    };\n\n    /**\n     * Keeps track of loaded lazy files status and references\n     */\n    private cache: { [url: string]: { lazyFile: LazyLoadedFile, observable: Observable<LazyLoadedFile> } };\n\n    constructor(private head: HeadService, private universal: UniversalService)\n    {\n        this.cache = {};\n    }\n\n    /**\n     * Checks whether the file from the specified url has already been cached.\n     * @param url The url for the file to check.\n     * @returns A value indicating whether the file from the specified url has already been cached.\n     */\n    public isCached(url: string): boolean\n    {\n        return !!this.cache[url];\n    }\n\n    /**\n     * Checks whether a script element is already present in `<head>` for the given url.\n     * This doesn't guarantee that the script has been loaded.\n     * \n     * @param {string} url The url of the loaded script.\n     * @returns {boolean} `true` if an element matching the url is present in `<head>`; otherwise `false.\n     */\n    public isScriptPresent(url: string): boolean\n    {\n        return this.head.contains('script', { src: url });\n    }\n\n    /**\n     * Checks whether a link element is already present in `<head>` for the given style url.\n     * This doesn't guarantee that the style has been loaded.\n     * \n     * @param {string} url The url of the loaded link.\n     * @returns {boolean} `true` if an element matching the url is present in `<head>`; otherwise `false.\n     */\n    public isStylePresent(url: string): boolean\n    {\n        return this.head.contains('link', { rel: 'stylesheet', href: url });\n    }\n\n    /**\n     * Loads a script programatically.\n     *\n     * @param url The full url of the script to load.\n     * @param options (Optional) Specifies custom options to override default behaviour.\n     * @returns An observable object which allows subscribers to know when the script has been loaded and access its associated `<script>` element.\n     *          The observable will complete immediately in case the script was already previously loaded.\n     *          If the script was already loaded outside of the service, the observable will stream `undefined`.\n     */\n    public loadScript(url: string, options: ScriptLoadOptions = this.defaultScriptOptions): Observable<LazyLoadedFile | null>\n    {\n        // Set default options if not specified by caller\n        options.async         = options.async         === undefined ? this.defaultScriptOptions.async : options.async;\n        options.defer         = options.defer         === undefined ? this.defaultScriptOptions.defer : options.defer;\n        options.alreadyLoaded = options.alreadyLoaded === undefined ? this.defaultScriptOptions.alreadyLoaded : options.alreadyLoaded;\n        options.force         = options.force         === undefined ? this.defaultScriptOptions.force : options.force;          \n\n        return this.loadFile(url, 'script', options as Required<ScriptLoadOptions>, this.createScriptElement.bind(this));\n    }\n\n    /**\n     * Loads a style programatically.\n     *\n     * @param url The full url of the style to load.\n     * @param options (Optional) Specifies custom options to override default behaviour.\n     * @returns An observable object which allows subscribers to know when the style has been loaded and access its associated `<link>` element.\n     *          The observable will complete immediately in case the style was already previously loaded.\n     *          If the style was already loaded outside of the service, the observable will stream `undefined`.\n     */\n    public loadStyle(url: string, options: LoadOptions = this.defaultStyleOptions): Observable<LazyLoadedFile | null>\n    {\n        // Set default options if not specified by caller\n        options.alreadyLoaded = options.alreadyLoaded === undefined ? this.defaultStyleOptions.alreadyLoaded : options.alreadyLoaded;\n        options.force         = options.force         === undefined ? this.defaultStyleOptions.force : options.force;\n\n        return this.loadFile(url, 'style', options as Required<LoadOptions>, this.createLinkElement.bind(this));\n    }\n\n    private loadFile(url: string, type: 'script' | 'style', options: Required<LoadOptions>, createElement: ElementCreator): Observable<LazyLoadedFile | null>\n    {\n        if (!this.universal.isPlatformBrowser) return of(null);\n\n        // If the script should be loaded, load it\n        if (!options.alreadyLoaded(url) || options.force)\n        {\n            // Initialize a base object to store the data later\n            const lazyFile: LazyLoadedFile = { url, type, completed: false, element: null };\n            // Create an observable that waits until the script has been loaded and executed\n            const observable = new Observable<LazyLoadedFile>(observer =>\n            {\n                // Create the callback that will mark the script as completed and notify the subscriber\n                const onLoad = () =>\n                {\n                    lazyFile.completed = true;\n\n                    observer.next(lazyFile);\n                    observer.complete();\n                };\n\n                // Create the actual file tag, start downloading and store the element reference\n                lazyFile.element = createElement(url, onLoad, observer.error.bind(observer), options);\n            });\n\n            // Cache the file and the observable for later use\n            this.cache[url] = { lazyFile: lazyFile, observable };\n\n            return observable;\n        }\n\n        // If the file was already loaded and it shouldn't be downloaded again, complete immediately with the previous link data.\n        // If the file was already loaded outside of the service, the observable will stream `undefined` as there is nothing cached.\n        return of(this.cache[url]?.lazyFile);\n    }\n\n    /**\n     * Creates a `<script>` tag for the given url and adds it to the `<head>` tag to start downloading the script.\n     *\n     * @param url       The url for the script to download.\n     * @param onLoad    The callback to execute when the script has been downloaded and executed.\n     * @param onError   The callback to execute when script download or execution has failed.\n     * @param options   The options to add to the script.\n     * @returns A reference to the `<script>` element that was added to the DOM.\n     */\n    private createScriptElement(url: string, onLoad: () => void, onError: (error: any) => void, options: ScriptLoadOptions): ElementRef<HTMLScriptElement>\n    {\n        return this.head.addScriptElement('text/javascript', url,\n            {\n                async: options.async,\n                defer: options.defer,\n                onload: onLoad,\n                onerror: onError\n            });\n    }\n\n    /**\n     * Creates a `<link>` tag for the given url and adds it to the `<head>` tag to start downloading the link.\n     *\n     * @param url       The url for the link to download.\n     * @param onLoad    The callback to execute when the script has been downloaded and executed.\n     * @param onError   The callback to execute when script download or execution has failed.\n     * @returns A reference to the `<link>` element that was added to the DOM.\n     */\n    private createLinkElement(url: string, onLoad: () => void, onError: (error: any) => void): ElementRef<HTMLLinkElement>\n    {\n        return this.head.addLinkElement('stylesheet',\n            {\n                type: 'text/css',\n                href: url,\n                onload: onLoad,\n                onerror: onError\n            });\n    }\n}\n"]}