ionic-image-loader-v7
Version:
ionic-image-loader to Ionic 6
240 lines • 25.5 kB
JavaScript
import { Component, EventEmitter, Input, Output } from '@angular/core';
import * as i0 from "@angular/core";
import * as i1 from "./services/image-loader.service";
import * as i2 from "./services/image-loader-config.service";
import * as i3 from "@ionic/angular";
import * as i4 from "@angular/common";
const propMap = {
display: 'display',
height: 'height',
width: 'width',
backgroundSize: 'background-size',
backgroundRepeat: 'background-repeat',
};
export class IonicImageLoaderComponent {
constructor(_element, renderer, imageLoader, config) {
this._element = _element;
this.renderer = renderer;
this.imageLoader = imageLoader;
this.config = config;
/**
* Fallback URL to load when the image url fails to load or does not exist.
*/
this.fallbackUrl = this.config.fallbackUrl;
/**
* Whether to show a spinner while the image loads
*/
this.spinner = this.config.spinnerEnabled;
/**
* Whether to show the fallback image instead of a spinner while the image loads
*/
this.fallbackAsPlaceholder = this.config.fallbackAsPlaceholder;
/**
* Attributes to pass through to img tag if _useImg == true
*/
this.imgAttributes = [];
/**
* Enable/Disable caching
*/
this.cache = true;
/**
* Width of the image. This will be ignored if using useImg.
*/
this.width = this.config.width;
/**
* Height of the image. This will be ignored if using useImg.
*/
this.height = this.config.height;
/**
* Display type of the image. This will be ignored if using useImg.
*/
this.display = this.config.display;
/**
* Background size. This will be ignored if using useImg.
*/
this.backgroundSize = this.config.backgroundSize;
/**
* Background repeat. This will be ignored if using useImg.
*/
this.backgroundRepeat = this.config.backgroundRepeat;
/**
* Name of the spinner
*/
this.spinnerName = this.config.spinnerName;
/**
* Color of the spinner
*/
this.spinnerColor = this.config.spinnerColor;
/**
* Notify on image load..
*/
this.load = new EventEmitter();
/**
* Indicates if the image is still loading
*/
this.isLoading = true;
this._useImg = this.config.useImg;
}
/**
* Use <img> tag
*/
set useImg(val) {
this._useImg = val !== false;
}
/**
* Convenience attribute to disable caching
*/
set noCache(val) {
this.cache = val !== false;
}
get src() {
return this._src;
}
/**
* The URL of the image to load.
*/
set src(imageUrl) {
this._src = this.processImageUrl(imageUrl);
this.updateImage(this._src);
}
ngOnInit() {
if (this.fallbackAsPlaceholder && this.fallbackUrl) {
this.setImage(this.fallbackUrl, false);
}
if (!this.src) {
// image url was not passed
// this can happen when [src] is set to a variable that turned out to be undefined
// one example could be a list of users with their profile pictures
// in this case, it would be useful to use the fallback image instead
// if fallbackUrl was used as placeholder we do not need to set it again
if (!this.fallbackAsPlaceholder && this.fallbackUrl) {
// we're not going to cache the fallback image since it should be locally saved
this.setImage(this.fallbackUrl);
}
else {
this.isLoading = false;
}
}
}
updateImage(imageUrl) {
this.imageLoader
.getImagePath(imageUrl)
.then((url) => this.setImage(url))
.catch((error) => this.setImage(this.fallbackUrl || imageUrl));
}
/**
* Gets the image URL to be loaded and disables caching if necessary
*/
processImageUrl(imageUrl) {
if (this.cache === false) {
// need to disable caching
if (imageUrl.indexOf('?') < 0) {
// add ? if doesn't exists
imageUrl += '?';
}
else {
imageUrl += '&';
}
// append timestamp at the end to make URL unique
imageUrl += 'cache_buster=' + Date.now();
}
return imageUrl;
}
/**
* Set the image to be displayed
* @param imageUrl image src
* @param stopLoading set to true to mark the image as loaded
*/
setImage(imageUrl, stopLoading = true) {
this.isLoading = !stopLoading;
if (this._useImg) {
// Using <img> tag
if (!this.element) {
// create img element if we dont have one
this.element = this.renderer.createElement('img');
this.renderer.appendChild(this._element.nativeElement, this.element);
}
// set it's src
this.renderer.setAttribute(this.element, 'src', imageUrl);
// if imgAttributes are defined, add them to our img element
this.imgAttributes.forEach((attribute) => {
this.renderer.setAttribute(this.element, attribute.element, attribute.value);
});
if (this.fallbackUrl && !this.imageLoader.nativeAvailable) {
this.renderer.listen(this.element, 'error', () => this.renderer.setAttribute(this.element, 'src', this.fallbackUrl));
}
}
else {
// Not using <img> tag
this.element = this._element.nativeElement;
for (const prop in propMap) {
if (this[prop]) {
this.renderer.setStyle(this.element, propMap[prop], this[prop]);
}
}
this.renderer.setStyle(this.element, 'background-image', `url("${imageUrl || this.fallbackUrl}")`);
}
if (stopLoading) {
this.load.emit(this);
}
}
}
IonicImageLoaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: IonicImageLoaderComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ImageLoaderService }, { token: i2.ImageLoaderConfigService }], target: i0.ɵɵFactoryTarget.Component });
IonicImageLoaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.1", type: IonicImageLoaderComponent, selector: "img-loader", inputs: { fallbackUrl: "fallbackUrl", spinner: "spinner", fallbackAsPlaceholder: "fallbackAsPlaceholder", imgAttributes: "imgAttributes", cache: "cache", width: "width", height: "height", display: "display", backgroundSize: "backgroundSize", backgroundRepeat: "backgroundRepeat", spinnerName: "spinnerName", spinnerColor: "spinnerColor", useImg: "useImg", noCache: "noCache", src: "src" }, outputs: { load: "load" }, ngImport: i0, template: `
<ion-spinner
*ngIf="spinner && isLoading && !fallbackAsPlaceholder"
[name]="spinnerName"
[color]="spinnerColor"
></ion-spinner>
<ng-content></ng-content>
`, isInline: true, styles: ["ion-spinner{float:none;margin-left:auto;margin-right:auto;display:block}\n"], components: [{ type: i3.IonSpinner, selector: "ion-spinner", inputs: ["color", "duration", "name", "paused"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.1", ngImport: i0, type: IonicImageLoaderComponent, decorators: [{
type: Component,
args: [{
selector: 'img-loader',
template: `
<ion-spinner
*ngIf="spinner && isLoading && !fallbackAsPlaceholder"
[name]="spinnerName"
[color]="spinnerColor"
></ion-spinner>
<ng-content></ng-content>
`,
styles: [
'ion-spinner { float: none; margin-left: auto; margin-right: auto; display: block; }',
],
}]
}], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ImageLoaderService }, { type: i2.ImageLoaderConfigService }]; }, propDecorators: { fallbackUrl: [{
type: Input
}], spinner: [{
type: Input
}], fallbackAsPlaceholder: [{
type: Input
}], imgAttributes: [{
type: Input
}], cache: [{
type: Input
}], width: [{
type: Input
}], height: [{
type: Input
}], display: [{
type: Input
}], backgroundSize: [{
type: Input
}], backgroundRepeat: [{
type: Input
}], spinnerName: [{
type: Input
}], spinnerColor: [{
type: Input
}], load: [{
type: Output
}], useImg: [{
type: Input
}], noCache: [{
type: Input
}], src: [{
type: Input
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ionic-image-loader.component.js","sourceRoot":"","sources":["../../../../projects/ionic-image-loader-v7/src/lib/ionic-image-loader.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnInit, Output, Renderer2 } from '@angular/core';\r\nimport { ImageLoaderConfigService } from './services/image-loader-config.service';\r\nimport { ImageLoaderService } from './services/image-loader.service';\r\n\r\nconst propMap: any = {\r\n  display: 'display',\r\n  height: 'height',\r\n  width: 'width',\r\n  backgroundSize: 'background-size',\r\n  backgroundRepeat: 'background-repeat',\r\n};\r\n\r\nexport interface ImageAttribute {\r\n  element: string;\r\n  value: string;\r\n}\r\n\r\n@Component({\r\n  selector: 'img-loader',\r\n  template: `\r\n    <ion-spinner\r\n        *ngIf=\"spinner && isLoading && !fallbackAsPlaceholder\"\r\n        [name]=\"spinnerName\"\r\n        [color]=\"spinnerColor\"\r\n    ></ion-spinner>\r\n    <ng-content></ng-content>\r\n  `,\r\n  styles: [\r\n    'ion-spinner { float: none; margin-left: auto; margin-right: auto; display: block; }',\r\n  ],\r\n})\r\nexport class IonicImageLoaderComponent implements OnInit {\r\n  /**\r\n   * Fallback URL to load when the image url fails to load or does not exist.\r\n   */\r\n  @Input() fallbackUrl: string = this.config.fallbackUrl;\r\n  /**\r\n   * Whether to show a spinner while the image loads\r\n   */\r\n  @Input() spinner: boolean = this.config.spinnerEnabled;\r\n  /**\r\n   * Whether to show the fallback image instead of a spinner while the image loads\r\n   */\r\n\r\n  @Input() fallbackAsPlaceholder: boolean = this.config.fallbackAsPlaceholder;\r\n  /**\r\n   * Attributes to pass through to img tag if _useImg == true\r\n   */\r\n  @Input() imgAttributes: ImageAttribute[] = [];\r\n  /**\r\n   * Enable/Disable caching\r\n   */\r\n  @Input() cache = true;\r\n  /**\r\n   * Width of the image. This will be ignored if using useImg.\r\n   */\r\n  @Input() width: string = this.config.width;\r\n  /**\r\n   * Height of the image. This will be ignored if using useImg.\r\n   */\r\n  @Input() height: string = this.config.height;\r\n  /**\r\n   * Display type of the image. This will be ignored if using useImg.\r\n   */\r\n  @Input() display: string = this.config.display;\r\n  /**\r\n   * Background size. This will be ignored if using useImg.\r\n   */\r\n  @Input() backgroundSize: string = this.config.backgroundSize;\r\n  /**\r\n   * Background repeat. This will be ignored if using useImg.\r\n   */\r\n  @Input() backgroundRepeat: string = this.config.backgroundRepeat;\r\n  /**\r\n   * Name of the spinner\r\n   */\r\n  @Input() spinnerName: string = this.config.spinnerName;\r\n  /**\r\n   * Color of the spinner\r\n   */\r\n  @Input() spinnerColor: string = this.config.spinnerColor;\r\n  /**\r\n   * Notify on image load..\r\n   */\r\n  @Output()\r\n  load: EventEmitter<IonicImageLoaderComponent> = new EventEmitter<IonicImageLoaderComponent>();\r\n  /**\r\n   * Indicates if the image is still loading\r\n   */\r\n  isLoading = true;\r\n  element: HTMLElement;\r\n\r\n  constructor(\r\n      private _element: ElementRef,\r\n      private renderer: Renderer2,\r\n      private imageLoader: ImageLoaderService,\r\n      private config: ImageLoaderConfigService,\r\n  ) {\r\n  }\r\n\r\n  private _useImg: boolean = this.config.useImg;\r\n\r\n  /**\r\n   * Use <img> tag\r\n   */\r\n  @Input()\r\n  set useImg(val: boolean) {\r\n    this._useImg = val !== false;\r\n  }\r\n\r\n  /**\r\n   * Convenience attribute to disable caching\r\n   */\r\n  @Input()\r\n  set noCache(val: boolean) {\r\n    this.cache = val !== false;\r\n  }\r\n\r\n  private _src: string;\r\n\r\n  get src(): string {\r\n    return this._src;\r\n  }\r\n\r\n  /**\r\n   * The URL of the image to load.\r\n   */\r\n  @Input()\r\n  set src(imageUrl: string) {\r\n    this._src = this.processImageUrl(imageUrl);\r\n    this.updateImage(this._src);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (this.fallbackAsPlaceholder && this.fallbackUrl) {\r\n      this.setImage(this.fallbackUrl, false);\r\n    }\r\n\r\n    if (!this.src) {\r\n      // image url was not passed\r\n      // this can happen when [src] is set to a variable that turned out to be undefined\r\n      // one example could be a list of users with their profile pictures\r\n      // in this case, it would be useful to use the fallback image instead\r\n      // if fallbackUrl was used as placeholder we do not need to set it again\r\n      if (!this.fallbackAsPlaceholder && this.fallbackUrl) {\r\n        // we're not going to cache the fallback image since it should be locally saved\r\n        this.setImage(this.fallbackUrl);\r\n      } else {\r\n        this.isLoading = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  private updateImage(imageUrl: string) {\r\n    this.imageLoader\r\n        .getImagePath(imageUrl)\r\n        .then((url: string) => this.setImage(url))\r\n        .catch((error: any) => this.setImage(this.fallbackUrl || imageUrl));\r\n  }\r\n\r\n  /**\r\n   * Gets the image URL to be loaded and disables caching if necessary\r\n   */\r\n  private processImageUrl(imageUrl: string): string {\r\n    if (this.cache === false) {\r\n      // need to disable caching\r\n\r\n      if (imageUrl.indexOf('?') < 0) {\r\n        // add ? if doesn't exists\r\n        imageUrl += '?';\r\n      } else {\r\n        imageUrl += '&';\r\n      }\r\n      // append timestamp at the end to make URL unique\r\n      imageUrl += 'cache_buster=' + Date.now();\r\n    }\r\n\r\n    return imageUrl;\r\n  }\r\n\r\n  /**\r\n   * Set the image to be displayed\r\n   * @param imageUrl image src\r\n   * @param stopLoading set to true to mark the image as loaded\r\n   */\r\n  private setImage(imageUrl: string, stopLoading: boolean = true): void {\r\n    this.isLoading = !stopLoading;\r\n\r\n    if (this._useImg) {\r\n      // Using <img> tag\r\n      if (!this.element) {\r\n        // create img element if we dont have one\r\n        this.element = this.renderer.createElement('img');\r\n        this.renderer.appendChild(this._element.nativeElement, this.element);\r\n      }\r\n\r\n      // set it's src\r\n      this.renderer.setAttribute(this.element, 'src', imageUrl);\r\n\r\n      // if imgAttributes are defined, add them to our img element\r\n      this.imgAttributes.forEach((attribute) => {\r\n        this.renderer.setAttribute(this.element, attribute.element, attribute.value);\r\n      });\r\n      if (this.fallbackUrl && !this.imageLoader.nativeAvailable) {\r\n        this.renderer.listen(this.element, 'error', () =>\r\n            this.renderer.setAttribute(this.element, 'src', this.fallbackUrl),\r\n        );\r\n      }\r\n    } else {\r\n      // Not using <img> tag\r\n\r\n      this.element = this._element.nativeElement;\r\n\r\n      for (const prop in propMap) {\r\n        if (this[prop]) {\r\n          this.renderer.setStyle(this.element, propMap[prop], this[prop]);\r\n        }\r\n      }\r\n      this.renderer.setStyle(\r\n          this.element,\r\n          'background-image',\r\n          `url(\"${imageUrl || this.fallbackUrl}\")`,\r\n      );\r\n    }\r\n    if (stopLoading) {\r\n      this.load.emit(this);\r\n    }\r\n  }\r\n}\r\n"]}