@ngx-gallery/core
Version:
Angular gallery directive that hooks the lightbox with the images automatically.
214 lines (211 loc) • 13.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, Input, HostBinding, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
import { DomSanitizer } from '@angular/platform-browser';
import { animate, style, transition, trigger } from '@angular/animations';
import { BehaviorSubject } from 'rxjs';
export class GalleryImageComponent {
/**
* @param {?} _sanitizer
*/
constructor(_sanitizer) {
this._sanitizer = _sanitizer;
/**
* Stream that emits the state
*/
this._state = new BehaviorSubject('loading');
this.state = this._state.asObservable();
/**
* Progress value
*/
this.progress = 0;
/**
* Stream that emits when an error occurs
*/
this.error = new EventEmitter();
}
/**
* @return {?}
*/
get imageLoadSuccess() {
return !!this.imageUrl;
}
/**
* @return {?}
*/
get imageLoadFailed() {
return !!this.loadError;
}
/**
* @return {?}
*/
ngOnInit() {
if (this.loadingIcon) {
this.loaderTemplate = this._sanitizer.bypassSecurityTrustHtml(this.loadingIcon);
}
if (this.loadingError) {
this.errorTemplate = this._sanitizer.bypassSecurityTrustHtml(this.loadingError);
}
}
/**
* @return {?}
*/
ngOnDestroy() {
this._state.complete();
}
/**
* @param {?} __0
* @return {?}
*/
onProgress({ loaded, total }) {
this.progress = loaded * 100 / total;
}
/**
* @param {?} blobUrl
* @return {?}
*/
onLoaded(blobUrl) {
this.imageUrl = this._sanitizer.bypassSecurityTrustStyle(`url(${blobUrl})`);
this._state.next('success');
}
/**
* @param {?} err
* @return {?}
*/
onError(err) {
this.loadError = err;
this._state.next('failed');
this.error.emit(err);
}
}
GalleryImageComponent.decorators = [
{ type: Component, args: [{
selector: 'gallery-image',
changeDetection: ChangeDetectionStrategy.OnPush,
animations: [
trigger('fadeIn', [
transition(':enter', [
style({ opacity: 0 }),
animate('300ms ease-in', style({ opacity: 1 }))
])
])
],
template: `
<ng-container [lazyImage]="src"
(progress)="onProgress($event)"
(loaded)="onLoaded($event)"
(error)="onError($event)"
[ngSwitch]="state | async">
<div *ngSwitchCase="'success'"
class="g-image-item"
[style.backgroundImage]="imageUrl">
</div>
<div *ngSwitchCase="'failed'"
class="g-image-error-message">
<div *ngIf="errorTemplate; else defaultError"
[innerHTML]="errorTemplate"></div>
<ng-template #defaultError>
<ng-container *ngIf="isThumbnail; else isLarge">
<h4>⚠</h4>
</ng-container>
<ng-template #isLarge>
<h2>⚠</h2>
<p>Unable to load the image!</p>
</ng-template>
</ng-template>
</div>
<ng-container *ngSwitchCase="'loading'">
<div *ngIf="loaderTemplate; else defaultLoader"
class="g-loading"
[innerHTML]="loaderTemplate">
</div>
<ng-template #defaultLoader>
<div *ngIf="isThumbnail" class="g-thumb-loading"></div>
</ng-template>
</ng-container>
</ng-container>
`
}] }
];
/** @nocollapse */
GalleryImageComponent.ctorParameters = () => [
{ type: DomSanitizer }
];
GalleryImageComponent.propDecorators = {
isThumbnail: [{ type: Input }],
src: [{ type: Input }],
loadingIcon: [{ type: Input }],
loadingError: [{ type: Input }],
error: [{ type: Output }],
imageLoadSuccess: [{ type: HostBinding, args: ['class.g-image-loaded',] }],
imageLoadFailed: [{ type: HostBinding, args: ['class.g-image-error',] }]
};
if (false) {
/**
* Stream that emits the state
* @type {?}
* @private
*/
GalleryImageComponent.prototype._state;
/** @type {?} */
GalleryImageComponent.prototype.state;
/**
* Progress value
* @type {?}
*/
GalleryImageComponent.prototype.progress;
/**
* Is thumbnail
* @type {?}
*/
GalleryImageComponent.prototype.isThumbnail;
/**
* Image source URL
* @type {?}
*/
GalleryImageComponent.prototype.src;
/**
* Loaded image URL
* @type {?}
*/
GalleryImageComponent.prototype.imageUrl;
/**
* Custom loader template
* @type {?}
*/
GalleryImageComponent.prototype.loadingIcon;
/**
* Custom loader safe template
* @type {?}
*/
GalleryImageComponent.prototype.loaderTemplate;
/**
* Custom error template
* @type {?}
*/
GalleryImageComponent.prototype.loadingError;
/**
* Custom error safe template
* @type {?}
*/
GalleryImageComponent.prototype.errorTemplate;
/**
* Stream that emits when an error occurs
* @type {?}
*/
GalleryImageComponent.prototype.error;
/**
* loading error
* @type {?}
*/
GalleryImageComponent.prototype.loadError;
/**
* @type {?}
* @private
*/
GalleryImageComponent.prototype._sanitizer;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gallery-image.component.js","sourceRoot":"ng://@ngx-gallery/core/","sources":["lib/components/templates/gallery-image.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, HostBinding, OnInit, Output, EventEmitter, ChangeDetectionStrategy, OnDestroy } from '@angular/core';\nimport { DomSanitizer, SafeHtml, SafeStyle } from '@angular/platform-browser';\nimport { animate, style, transition, trigger } from '@angular/animations';\nimport { BehaviorSubject } from 'rxjs';\n\n@Component({\n  selector: 'gallery-image',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  animations: [\n    trigger('fadeIn', [\n      transition(':enter', [\n        style({opacity: 0}),\n        animate('300ms ease-in', style({opacity: 1}))\n      ])\n    ])\n  ],\n  template: `\n    <ng-container [lazyImage]=\"src\"\n                  (progress)=\"onProgress($event)\"\n                  (loaded)=\"onLoaded($event)\"\n                  (error)=\"onError($event)\"\n                  [ngSwitch]=\"state | async\">\n\n      <div *ngSwitchCase=\"'success'\"\n           @fadeIn\n           class=\"g-image-item\"\n           [style.backgroundImage]=\"imageUrl\">\n      </div>\n\n      <div *ngSwitchCase=\"'failed'\"\n           class=\"g-image-error-message\">\n        <div *ngIf=\"errorTemplate; else defaultError\"\n             [innerHTML]=\"errorTemplate\"></div>\n        <ng-template #defaultError>\n          <ng-container *ngIf=\"isThumbnail; else isLarge\">\n            <h4>⚠</h4>\n          </ng-container>\n          <ng-template #isLarge>\n            <h2>⚠</h2>\n            <p>Unable to load the image!</p>\n          </ng-template>\n        </ng-template>\n      </div>\n\n      <ng-container *ngSwitchCase=\"'loading'\">\n        <div *ngIf=\"loaderTemplate; else defaultLoader\"\n             class=\"g-loading\"\n             [innerHTML]=\"loaderTemplate\">\n        </div>\n        <ng-template #defaultLoader>\n          <div *ngIf=\"isThumbnail\" class=\"g-thumb-loading\"></div>\n        </ng-template>\n      </ng-container>\n    </ng-container>\n  `\n})\n\nexport class GalleryImageComponent implements OnInit, OnDestroy {\n\n  /** Stream that emits the state */\n  private readonly _state = new BehaviorSubject<'loading' | 'success' | 'failed'>('loading');\n  readonly state = this._state.asObservable();\n\n  /** Progress value */\n  progress = 0;\n\n  /** Is thumbnail */\n  @Input() isThumbnail: boolean;\n\n  /** Image source URL */\n  @Input() src: string;\n  /** Loaded image URL */\n  imageUrl: SafeStyle;\n\n  /** Custom loader template */\n  @Input() loadingIcon: string;\n  /** Custom loader safe template */\n  loaderTemplate: SafeHtml;\n\n  /** Custom error template */\n  @Input() loadingError: string;\n  /** Custom error safe template */\n  errorTemplate: SafeHtml;\n\n  /** Stream that emits when an error occurs */\n  @Output() error = new EventEmitter<Error>();\n  /** loading error */\n  loadError: Error;\n\n  @HostBinding('class.g-image-loaded') get imageLoadSuccess(): boolean {\n    return !!this.imageUrl;\n  }\n\n  @HostBinding('class.g-image-error') get imageLoadFailed(): boolean {\n    return !!this.loadError;\n  }\n\n  constructor(private _sanitizer: DomSanitizer) {\n  }\n\n  ngOnInit() {\n    if (this.loadingIcon) {\n      this.loaderTemplate = this._sanitizer.bypassSecurityTrustHtml(this.loadingIcon);\n    }\n    if (this.loadingError) {\n      this.errorTemplate = this._sanitizer.bypassSecurityTrustHtml(this.loadingError);\n    }\n  }\n\n  ngOnDestroy() {\n    this._state.complete();\n  }\n\n  onProgress({loaded, total}: { loaded: number, total: number }) {\n    this.progress = loaded * 100 / total;\n  }\n\n  onLoaded(blobUrl: string) {\n    this.imageUrl = this._sanitizer.bypassSecurityTrustStyle(`url(${blobUrl})`);\n    this._state.next('success');\n  }\n\n  onError(err: Error) {\n    this.loadError = err;\n    this._state.next('failed');\n    this.error.emit(err);\n  }\n\n}\n"]}