ionic-image-loader-v5
Version:
ionic-image-loader to Ionic 5
425 lines • 29.1 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: lib/ionic-image-loader.component.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, ElementRef, EventEmitter, Input, Output, Renderer2 } from '@angular/core';
import { ImageLoaderConfigService } from './services/image-loader-config.service';
import { ImageLoaderService } from './services/image-loader.service';
/** @type {?} */
var propMap = {
display: 'display',
height: 'height',
width: 'width',
backgroundSize: 'background-size',
backgroundRepeat: 'background-repeat',
};
/**
* @record
*/
export function ImageAttribute() { }
if (false) {
/** @type {?} */
ImageAttribute.prototype.element;
/** @type {?} */
ImageAttribute.prototype.value;
}
var IonicImageLoaderComponent = /** @class */ (function () {
function IonicImageLoaderComponent(_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;
}
Object.defineProperty(IonicImageLoaderComponent.prototype, "useImg", {
/**
* Use <img> tag
*/
set: /**
* Use <img> tag
* @param {?} val
* @return {?}
*/
function (val) {
this._useImg = val !== false;
},
enumerable: true,
configurable: true
});
Object.defineProperty(IonicImageLoaderComponent.prototype, "noCache", {
/**
* Convenience attribute to disable caching
*/
set: /**
* Convenience attribute to disable caching
* @param {?} val
* @return {?}
*/
function (val) {
this.cache = val !== false;
},
enumerable: true,
configurable: true
});
Object.defineProperty(IonicImageLoaderComponent.prototype, "src", {
get: /**
* @return {?}
*/
function () {
return this._src;
},
/**
* The URL of the image to load.
*/
set: /**
* The URL of the image to load.
* @param {?} imageUrl
* @return {?}
*/
function (imageUrl) {
this._src = this.processImageUrl(imageUrl);
this.updateImage(this._src);
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
IonicImageLoaderComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
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;
}
}
};
/**
* @private
* @param {?} imageUrl
* @return {?}
*/
IonicImageLoaderComponent.prototype.updateImage = /**
* @private
* @param {?} imageUrl
* @return {?}
*/
function (imageUrl) {
var _this = this;
this.imageLoader
.getImagePath(imageUrl)
.then((/**
* @param {?} url
* @return {?}
*/
function (url) { return _this.setImage(url); }))
.catch((/**
* @param {?} error
* @return {?}
*/
function (error) { return _this.setImage(_this.fallbackUrl || imageUrl); }));
};
/**
* Gets the image URL to be loaded and disables caching if necessary
*/
/**
* Gets the image URL to be loaded and disables caching if necessary
* @private
* @param {?} imageUrl
* @return {?}
*/
IonicImageLoaderComponent.prototype.processImageUrl = /**
* Gets the image URL to be loaded and disables caching if necessary
* @private
* @param {?} imageUrl
* @return {?}
*/
function (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
*/
/**
* Set the image to be displayed
* @private
* @param {?} imageUrl image src
* @param {?=} stopLoading set to true to mark the image as loaded
* @return {?}
*/
IonicImageLoaderComponent.prototype.setImage = /**
* Set the image to be displayed
* @private
* @param {?} imageUrl image src
* @param {?=} stopLoading set to true to mark the image as loaded
* @return {?}
*/
function (imageUrl, stopLoading) {
var _this = this;
if (stopLoading === void 0) { 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((/**
* @param {?} attribute
* @return {?}
*/
function (attribute) {
_this.renderer.setAttribute(_this.element, attribute.element, attribute.value);
}));
if (this.fallbackUrl && !this.imageLoader.nativeAvailable) {
this.renderer.listen(this.element, 'error', (/**
* @return {?}
*/
function () {
return _this.renderer.setAttribute(_this.element, 'src', _this.fallbackUrl);
}));
}
}
else {
// Not using <img> tag
this.element = this._element.nativeElement;
for (var 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.decorators = [
{ type: Component, args: [{
selector: 'img-loader',
template: "\n <ion-spinner\n *ngIf=\"spinner && isLoading && !fallbackAsPlaceholder\"\n [name]=\"spinnerName\"\n [color]=\"spinnerColor\"\n ></ion-spinner>\n <ng-content></ng-content>\n ",
styles: ['ion-spinner { float: none; margin-left: auto; margin-right: auto; display: block; }']
}] }
];
/** @nocollapse */
IonicImageLoaderComponent.ctorParameters = function () { return [
{ type: ElementRef },
{ type: Renderer2 },
{ type: ImageLoaderService },
{ type: ImageLoaderConfigService }
]; };
IonicImageLoaderComponent.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 }]
};
return IonicImageLoaderComponent;
}());
export { IonicImageLoaderComponent };
if (false) {
/**
* Fallback URL to load when the image url fails to load or does not exist.
* @type {?}
*/
IonicImageLoaderComponent.prototype.fallbackUrl;
/**
* Whether to show a spinner while the image loads
* @type {?}
*/
IonicImageLoaderComponent.prototype.spinner;
/**
* Whether to show the fallback image instead of a spinner while the image loads
* @type {?}
*/
IonicImageLoaderComponent.prototype.fallbackAsPlaceholder;
/**
* Attributes to pass through to img tag if _useImg == true
* @type {?}
*/
IonicImageLoaderComponent.prototype.imgAttributes;
/**
* Enable/Disable caching
* @type {?}
*/
IonicImageLoaderComponent.prototype.cache;
/**
* Width of the image. This will be ignored if using useImg.
* @type {?}
*/
IonicImageLoaderComponent.prototype.width;
/**
* Height of the image. This will be ignored if using useImg.
* @type {?}
*/
IonicImageLoaderComponent.prototype.height;
/**
* Display type of the image. This will be ignored if using useImg.
* @type {?}
*/
IonicImageLoaderComponent.prototype.display;
/**
* Background size. This will be ignored if using useImg.
* @type {?}
*/
IonicImageLoaderComponent.prototype.backgroundSize;
/**
* Background repeat. This will be ignored if using useImg.
* @type {?}
*/
IonicImageLoaderComponent.prototype.backgroundRepeat;
/**
* Name of the spinner
* @type {?}
*/
IonicImageLoaderComponent.prototype.spinnerName;
/**
* Color of the spinner
* @type {?}
*/
IonicImageLoaderComponent.prototype.spinnerColor;
/**
* Notify on image load..
* @type {?}
*/
IonicImageLoaderComponent.prototype.load;
/**
* Indicates if the image is still loading
* @type {?}
*/
IonicImageLoaderComponent.prototype.isLoading;
/** @type {?} */
IonicImageLoaderComponent.prototype.element;
/**
* @type {?}
* @private
*/
IonicImageLoaderComponent.prototype._useImg;
/**
* @type {?}
* @private
*/
IonicImageLoaderComponent.prototype._src;
/**
* @type {?}
* @private
*/
IonicImageLoaderComponent.prototype._element;
/**
* @type {?}
* @private
*/
IonicImageLoaderComponent.prototype.renderer;
/**
* @type {?}
* @private
*/
IonicImageLoaderComponent.prototype.imageLoader;
/**
* @type {?}
* @private
*/
IonicImageLoaderComponent.prototype.config;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ionic-image-loader.component.js","sourceRoot":"ng://ionic-image-loader-v5/","sources":["lib/ionic-image-loader.component.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,EAAU,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACtG,OAAO,EAAE,wBAAwB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;;IAE/D,OAAO,GAAQ;IACnB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;IAChB,KAAK,EAAE,OAAO;IACd,cAAc,EAAE,iBAAiB;IACjC,gBAAgB,EAAE,mBAAmB;CACtC;;;;AAED,oCAGC;;;IAFC,iCAAgB;;IAChB,+BAAc;;AAGhB;IA2EE,mCACY,QAAoB,EACpB,QAAmB,EACnB,WAA+B,EAC/B,MAAgC;QAHhC,aAAQ,GAAR,QAAQ,CAAY;QACpB,aAAQ,GAAR,QAAQ,CAAW;QACnB,gBAAW,GAAX,WAAW,CAAoB;QAC/B,WAAM,GAAN,MAAM,CAA0B;;;;QA7DnC,gBAAW,GAAW,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;;;;QAI9C,YAAO,GAAY,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;;;;QAK9C,0BAAqB,GAAY,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC;;;;QAInE,kBAAa,GAAqB,EAAE,CAAC;;;;QAIrC,UAAK,GAAG,IAAI,CAAC;;;;QAIb,UAAK,GAAW,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;;;;QAIlC,WAAM,GAAW,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;;;;QAIpC,YAAO,GAAW,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;;;;QAItC,mBAAc,GAAW,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;;;;QAIpD,qBAAgB,GAAW,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;;;;QAIxD,gBAAW,GAAW,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;;;;QAI9C,iBAAY,GAAW,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;;;;QAKzD,SAAI,GAA4C,IAAI,YAAY,EAA6B,CAAC;;;;QAI9F,cAAS,GAAG,IAAI,CAAC;QAWT,YAAO,GAAY,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;IAF9C,CAAC;IAOD,sBACI,6CAAM;QAJV;;WAEG;;;;;;QACH,UACW,GAAY;YACrB,IAAI,CAAC,OAAO,GAAG,GAAG,KAAK,KAAK,CAAC;QAC/B,CAAC;;;OAAA;IAKD,sBACI,8CAAO;QAJX;;WAEG;;;;;;QACH,UACY,GAAY;YACtB,IAAI,CAAC,KAAK,GAAG,GAAG,KAAK,KAAK,CAAC;QAC7B,CAAC;;;OAAA;IAID,sBAAI,0CAAG;;;;QAAP;YACE,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;QAED;;WAEG;;;;;;QACH,UACQ,QAAgB;YACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;YAC3C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;;;OATA;;;;IAWD,4CAAQ;;;IAAR;QACE,IAAI,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,WAAW,EAAE;YAClD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;SACxC;QAED,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;YACb,2BAA2B;YAC3B,kFAAkF;YAClF,mEAAmE;YACnE,qEAAqE;YACrE,wEAAwE;YACxE,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,WAAW,EAAE;gBACnD,+EAA+E;gBAC/E,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aACjC;iBAAM;gBACL,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;aACxB;SACF;IACH,CAAC;;;;;;IAEO,+CAAW;;;;;IAAnB,UAAoB,QAAgB;QAApC,iBAKC;QAJC,IAAI,CAAC,WAAW;aACX,YAAY,CAAC,QAAQ,CAAC;aACtB,IAAI;;;;QAAC,UAAC,GAAW,IAAK,OAAA,KAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAlB,CAAkB,EAAC;aACzC,KAAK;;;;QAAC,UAAC,KAAU,IAAK,OAAA,KAAI,CAAC,QAAQ,CAAC,KAAI,CAAC,WAAW,IAAI,QAAQ,CAAC,EAA3C,CAA2C,EAAC,CAAC;IAC1E,CAAC;IAED;;OAEG;;;;;;;IACK,mDAAe;;;;;;IAAvB,UAAwB,QAAgB;QACtC,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,EAAE;YACxB,0BAA0B;YAE1B,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBAC7B,0BAA0B;gBAC1B,QAAQ,IAAI,GAAG,CAAC;aACjB;iBAAM;gBACL,QAAQ,IAAI,GAAG,CAAC;aACjB;YACD,iDAAiD;YACjD,QAAQ,IAAI,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;SAC1C;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;OAIG;;;;;;;;IACK,4CAAQ;;;;;;;IAAhB,UAAiB,QAAgB,EAAE,WAA2B;QAA9D,iBA0CC;QA1CkC,4BAAA,EAAA,kBAA2B;QAC5D,IAAI,CAAC,SAAS,GAAG,CAAC,WAAW,CAAC;QAE9B,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,kBAAkB;YAClB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;gBACjB,yCAAyC;gBACzC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBAClD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;aACtE;YAED,eAAe;YACf,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;YAE1D,4DAA4D;YAC5D,IAAI,CAAC,aAAa,CAAC,OAAO;;;;YAAC,UAAC,SAAS;gBACnC,KAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,KAAI,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;YAC/E,CAAC,EAAC,CAAC;YACH,IAAI,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE;gBACzD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO;;;gBAAE;oBACxC,OAAA,KAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,KAAI,CAAC,OAAO,EAAE,KAAK,EAAE,KAAI,CAAC,WAAW,CAAC;gBAAjE,CAAiE,EACpE,CAAC;aACH;SACF;aAAM;YACL,sBAAsB;YAEtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;YAE3C,KAAK,IAAM,IAAI,IAAI,OAAO,EAAE;gBAC1B,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE;oBACd,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;iBACjE;aACF;YACD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAClB,IAAI,CAAC,OAAO,EACZ,kBAAkB,EAClB,YAAQ,QAAQ,IAAI,IAAI,CAAC,WAAW,SAAI,CAC3C,CAAC;SACH;QACD,IAAI,WAAW,EAAE;YACf,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACtB;IACH,CAAC;;gBAlNF,SAAS,SAAC;oBACT,QAAQ,EAAE,YAAY;oBACtB,QAAQ,EAAE,gNAOT;6BAEC,qFAAqF;iBAExF;;;;gBA9BmB,UAAU;gBAAuC,SAAS;gBAErE,kBAAkB;gBADlB,wBAAwB;;;8BAkC9B,KAAK;0BAIL,KAAK;wCAKL,KAAK;gCAIL,KAAK;wBAIL,KAAK;wBAIL,KAAK;yBAIL,KAAK;0BAIL,KAAK;iCAIL,KAAK;mCAIL,KAAK;8BAIL,KAAK;+BAIL,KAAK;uBAIL,MAAM;yBAqBN,KAAK;0BAQL,KAAK;sBAcL,KAAK;;IAqGR,gCAAC;CAAA,AAnND,IAmNC;SArMY,yBAAyB;;;;;;IAIpC,gDAAuD;;;;;IAIvD,4CAAuD;;;;;IAKvD,0DAA4E;;;;;IAI5E,kDAA8C;;;;;IAI9C,0CAAsB;;;;;IAItB,0CAA2C;;;;;IAI3C,2CAA6C;;;;;IAI7C,4CAA+C;;;;;IAI/C,mDAA6D;;;;;IAI7D,qDAAiE;;;;;IAIjE,gDAAuD;;;;;IAIvD,iDAAyD;;;;;IAIzD,yCAC8F;;;;;IAI9F,8CAAiB;;IACjB,4CAAqB;;;;;IAUrB,4CAA8C;;;;;IAkB9C,yCAAqB;;;;;IAzBjB,6CAA4B;;;;;IAC5B,6CAA2B;;;;;IAC3B,gDAAuC;;;;;IACvC,2CAAwC","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnInit, Output, Renderer2 } from '@angular/core';\nimport { ImageLoaderConfigService } from './services/image-loader-config.service';\nimport { ImageLoaderService } from './services/image-loader.service';\n\nconst propMap: any = {\n  display: 'display',\n  height: 'height',\n  width: 'width',\n  backgroundSize: 'background-size',\n  backgroundRepeat: 'background-repeat',\n};\n\nexport interface ImageAttribute {\n  element: string;\n  value: string;\n}\n\n@Component({\n  selector: 'img-loader',\n  template: `\n    <ion-spinner\n        *ngIf=\"spinner && isLoading && !fallbackAsPlaceholder\"\n        [name]=\"spinnerName\"\n        [color]=\"spinnerColor\"\n    ></ion-spinner>\n    <ng-content></ng-content>\n  `,\n  styles: [\n    'ion-spinner { float: none; margin-left: auto; margin-right: auto; display: block; }',\n  ],\n})\nexport class IonicImageLoaderComponent implements OnInit {\n  /**\n   * Fallback URL to load when the image url fails to load or does not exist.\n   */\n  @Input() fallbackUrl: string = this.config.fallbackUrl;\n  /**\n   * Whether to show a spinner while the image loads\n   */\n  @Input() spinner: boolean = this.config.spinnerEnabled;\n  /**\n   * Whether to show the fallback image instead of a spinner while the image loads\n   */\n\n  @Input() fallbackAsPlaceholder: boolean = this.config.fallbackAsPlaceholder;\n  /**\n   * Attributes to pass through to img tag if _useImg == true\n   */\n  @Input() imgAttributes: ImageAttribute[] = [];\n  /**\n   * Enable/Disable caching\n   */\n  @Input() cache = true;\n  /**\n   * Width of the image. This will be ignored if using useImg.\n   */\n  @Input() width: string = this.config.width;\n  /**\n   * Height of the image. This will be ignored if using useImg.\n   */\n  @Input() height: string = this.config.height;\n  /**\n   * Display type of the image. This will be ignored if using useImg.\n   */\n  @Input() display: string = this.config.display;\n  /**\n   * Background size. This will be ignored if using useImg.\n   */\n  @Input() backgroundSize: string = this.config.backgroundSize;\n  /**\n   * Background repeat. This will be ignored if using useImg.\n   */\n  @Input() backgroundRepeat: string = this.config.backgroundRepeat;\n  /**\n   * Name of the spinner\n   */\n  @Input() spinnerName: string = this.config.spinnerName;\n  /**\n   * Color of the spinner\n   */\n  @Input() spinnerColor: string = this.config.spinnerColor;\n  /**\n   * Notify on image load..\n   */\n  @Output()\n  load: EventEmitter<IonicImageLoaderComponent> = new EventEmitter<IonicImageLoaderComponent>();\n  /**\n   * Indicates if the image is still loading\n   */\n  isLoading = true;\n  element: HTMLElement;\n\n  constructor(\n      private _element: ElementRef,\n      private renderer: Renderer2,\n      private imageLoader: ImageLoaderService,\n      private config: ImageLoaderConfigService,\n  ) {\n  }\n\n  private _useImg: boolean = this.config.useImg;\n\n  /**\n   * Use <img> tag\n   */\n  @Input()\n  set useImg(val: boolean) {\n    this._useImg = val !== false;\n  }\n\n  /**\n   * Convenience attribute to disable caching\n   */\n  @Input()\n  set noCache(val: boolean) {\n    this.cache = val !== false;\n  }\n\n  private _src: string;\n\n  get src(): string {\n    return this._src;\n  }\n\n  /**\n   * The URL of the image to load.\n   */\n  @Input()\n  set src(imageUrl: string) {\n    this._src = this.processImageUrl(imageUrl);\n    this.updateImage(this._src);\n  }\n\n  ngOnInit(): void {\n    if (this.fallbackAsPlaceholder && this.fallbackUrl) {\n      this.setImage(this.fallbackUrl, false);\n    }\n\n    if (!this.src) {\n      // image url was not passed\n      // this can happen when [src] is set to a variable that turned out to be undefined\n      // one example could be a list of users with their profile pictures\n      // in this case, it would be useful to use the fallback image instead\n      // if fallbackUrl was used as placeholder we do not need to set it again\n      if (!this.fallbackAsPlaceholder && this.fallbackUrl) {\n        // we're not going to cache the fallback image since it should be locally saved\n        this.setImage(this.fallbackUrl);\n      } else {\n        this.isLoading = false;\n      }\n    }\n  }\n\n  private updateImage(imageUrl: string) {\n    this.imageLoader\n        .getImagePath(imageUrl)\n        .then((url: string) => this.setImage(url))\n        .catch((error: any) => this.setImage(this.fallbackUrl || imageUrl));\n  }\n\n  /**\n   * Gets the image URL to be loaded and disables caching if necessary\n   */\n  private processImageUrl(imageUrl: string): string {\n    if (this.cache === false) {\n      // need to disable caching\n\n      if (imageUrl.indexOf('?') < 0) {\n        // add ? if doesn't exists\n        imageUrl += '?';\n      } else {\n        imageUrl += '&';\n      }\n      // append timestamp at the end to make URL unique\n      imageUrl += 'cache_buster=' + Date.now();\n    }\n\n    return imageUrl;\n  }\n\n  /**\n   * Set the image to be displayed\n   * @param imageUrl image src\n   * @param stopLoading set to true to mark the image as loaded\n   */\n  private setImage(imageUrl: string, stopLoading: boolean = true): void {\n    this.isLoading = !stopLoading;\n\n    if (this._useImg) {\n      // Using <img> tag\n      if (!this.element) {\n        // create img element if we dont have one\n        this.element = this.renderer.createElement('img');\n        this.renderer.appendChild(this._element.nativeElement, this.element);\n      }\n\n      // set it's src\n      this.renderer.setAttribute(this.element, 'src', imageUrl);\n\n      // if imgAttributes are defined, add them to our img element\n      this.imgAttributes.forEach((attribute) => {\n        this.renderer.setAttribute(this.element, attribute.element, attribute.value);\n      });\n      if (this.fallbackUrl && !this.imageLoader.nativeAvailable) {\n        this.renderer.listen(this.element, 'error', () =>\n            this.renderer.setAttribute(this.element, 'src', this.fallbackUrl),\n        );\n      }\n    } else {\n      // Not using <img> tag\n\n      this.element = this._element.nativeElement;\n\n      for (const prop in propMap) {\n        if (this[prop]) {\n          this.renderer.setStyle(this.element, propMap[prop], this[prop]);\n        }\n      }\n      this.renderer.setStyle(\n          this.element,\n          'background-image',\n          `url(\"${imageUrl || this.fallbackUrl}\")`,\n      );\n    }\n    if (stopLoading) {\n      this.load.emit(this);\n    }\n  }\n}\n"]}