ngx-pluto
Version:
303 lines • 24.1 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, ViewEncapsulation, Input, Output, EventEmitter, forwardRef } from "@angular/core";
import { DomSanitizer } from "@angular/platform-browser";
import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from "@angular/forms";
import { Utils } from "../common/utils";
/**
* 图片上传组件 - 支持NgModel和reactive forms
*
* <example-url>https://stackblitz.com/edit/np-img-upload-sample?embed=1&file=src/app/app.component.html</example-url>
*/
export class NpImgUpload {
/**
* @param {?} sanitizer
*/
constructor(sanitizer) {
this.sanitizer = sanitizer;
this.emitChange = (/**
* @param {?} _
* @return {?}
*/
(_) => { });
/**
* 标签
*/
this.label = '选择图片';
/**
* 是否忽略宽高检查，true - 忽略宽高检查，false - 检查宽高
*/
this.ignoreWidthAndHeightCheck = false;
/**
* 上传图片按钮文字
*/
this.btnText = '点击上传';
/**
* 图片描述，如尺寸、格式、大小等
*/
this.imgDesc = '*图片描述，如尺寸、格式、大小等*';
/**
* 图片格式，默认jpg、png和jpeg
*/
this.imgFormat = 'jpg|png|jpeg';
/**
* 图片大小，默认最大500kb
*/
this.maxSize = 500;
/**
* 当重新选择图片时触发
*/
this.onImgFileChanged = new EventEmitter();
/**
* 上传错误，如尺寸不对、格式不对，大小不对等
*/
this.onUploadError = new EventEmitter();
/**
* 点击缩略图是触发
*/
this.onImgClicked = new EventEmitter();
this.currentImgFile = null;
this.currentImgSrc = null;
}
/**
* @return {?}
*/
ngOnInit() {
}
/**
* @param {?} file
* @return {?}
*/
onCurrentImgFileChanged(file) {
/** @type {?} */
const filename = file.name;
/** @type {?} */
const reg = new RegExp(`\.(${this.imgFormat.toLowerCase()})|.(${this.imgFormat.toUpperCase()})$`);
if (!reg.test(filename)) {
this.errorMessage = '图片格式不对，支持' + this.imgFormat.split('|').join('、');
this.onUploadError.next(this.errorMessage);
this.emitChange({ file: null, src: null });
return;
}
if (file.size > +this.maxSize * 1024) {
this.errorMessage = '图片大于' + this.maxSize + 'kb，请重新选择';
this.onUploadError.next(this.errorMessage);
this.emitChange({ file: null, src: null });
return;
}
Utils.checkImgWidthAndHeight(file, +this.width, +this.height).subscribe((/**
* @param {?} res
* @return {?}
*/
res => {
if (!res && !this.ignoreWidthAndHeightCheck) {
this.errorMessage = '图片大小必须为' + this.width + '*' + this.height;
this.onUploadError.next(this.errorMessage);
this.emitChange({ file: null, src: null });
return;
}
this.errorMessage = '';
this.currentImgSrc = this.sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(file));
this.currentImgFile = file;
this.emitChange({ file: this.currentImgFile, src: this.currentImgSrc });
this.onImgFileChanged.next({ file: this.currentImgFile, src: this.currentImgSrc });
return true;
}));
}
/**
* @param {?} msg
* @return {?}
*/
onUploadImgFormatError(msg) {
this.errorMessage = '图片格式不对，支持' + this.imgFormat.split('|').join('、');
this.onUploadError.next(this.errorMessage);
this.emitChange({ file: null, src: null });
}
/**
* @return {?}
*/
onCurrentImgClick() {
this.onImgClicked.next({ file: this.currentImgFile, src: this.currentImgSrc });
}
/**
* @param {?} obj
* @return {?}
*/
writeValue(obj) {
if (obj) {
this.currentImgFile = obj.file;
this.currentImgSrc = obj.src;
}
else {
this.currentImgFile = null;
this.currentImgSrc = null;
}
}
/**
* @param {?} control
* @return {?}
*/
validate(control) {
if (this.isRequired) {
if (control && control.value && !control.value.file && !control.value.src) {
return { 'imgError': true };
}
if (control && !control.value) {
return { 'imgError': true };
}
}
return null;
}
/**
* @param {?} fn
* @return {?}
*/
registerOnChange(fn) {
this.emitChange = fn;
}
/**
* @param {?} fn
* @return {?}
*/
registerOnTouched(fn) { }
/**
* @param {?} isDisabled
* @return {?}
*/
setDisabledState(isDisabled) { }
}
NpImgUpload.decorators = [
{ type: Component, args: [{
selector: `np-img-upload`,
template: "<div class=\"img-upload-wrapper flex-wrap col-flex\">\r\n <div class=\"flex-wrap row-flex\" style=\"align-items: baseline;\">\r\n <label class=\"img-label\">\r\n <span class=\"form-required\" *ngIf=\"isRequired\">*</span>\r\n {{ label }}\r\n </label>\r\n <np-button buttonType=\"secondary\" [funcType]=\"'upload'\" [isDisabled]=\"isDisabled\" [uploadFileType]=\"imgFormat\"\r\n (uploadErrorMessage)=\"onUploadImgFormatError($event)\" [file]=\"currentImgFile\"\r\n (fileChange)=\"onCurrentImgFileChanged($event)\">{{ btnText }}\r\n </np-button>\r\n </div>\r\n <span class=\"error-message\" *ngIf=\"errorMessage\" style=\"margin-left: 100px;\">{{ errorMessage }}</span>\r\n <div class=\"img-thumbnail-container flex-wrap col-flex middle-flex\" (click)=\"onCurrentImgClick()\">\r\n <img *ngIf=\"currentImgSrc\" [src]=\"currentImgSrc\">\r\n <div *ngIf=\"!currentImgSrc\" class=\"img-placeholder flex-wrap col-flex middle-flex\">\r\n <span>+</span>\r\n </div>\r\n </div>\r\n <span [innerHtml]=\"imgDesc | safeHtml\" class=\"img-desc\"></span>\r\n</div>\r\n",
providers: [
{
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef((/**
* @return {?}
*/
() => NpImgUpload)),
multi: true,
},
{
provide: NG_VALIDATORS,
useExisting: forwardRef((/**
* @return {?}
*/
() => NpImgUpload)),
multi: true,
}
],
encapsulation: ViewEncapsulation.None,
styles: [".img-upload-wrapper .error-message{display:block;font-size:10px;margin:5px}.img-upload-wrapper .img-thumbnail-container{width:220px;height:160px;padding:15px;margin-top:10px;margin-left:100px;border:2.5px dashed #aaa}.img-upload-wrapper .img-thumbnail-container>.img-placeholder,.img-upload-wrapper .img-thumbnail-container>img{width:160px;height:auto;max-height:120px}.img-upload-wrapper .img-thumbnail-container>.img-placeholder{font-size:18px}.img-upload-wrapper .img-thumbnail-container>.img-placeholder span{font-size:40px;font-weight:500;color:#aaa}.img-upload-wrapper .img-label{width:80px;text-align:right;margin-right:20px;font-weight:700}.img-upload-wrapper .img-desc{font-size:12px;margin-top:10px;margin-left:100px}.img-upload-wrapper .button-secondary{margin:0!important}"]
}] }
];
/** @nocollapse */
NpImgUpload.ctorParameters = () => [
{ type: DomSanitizer }
];
NpImgUpload.propDecorators = {
label: [{ type: Input }],
isDisabled: [{ type: Input }],
ignoreWidthAndHeightCheck: [{ type: Input }],
isRequired: [{ type: Input }],
btnText: [{ type: Input }],
imgDesc: [{ type: Input }],
imgFormat: [{ type: Input }],
maxSize: [{ type: Input }],
width: [{ type: Input }],
height: [{ type: Input }],
errorMessage: [{ type: Input }],
onImgFileChanged: [{ type: Output }],
onUploadError: [{ type: Output }],
onImgClicked: [{ type: Output }]
};
if (false) {
/**
* @type {?}
* @private
*/
NpImgUpload.prototype.emitChange;
/**
* 标签
* @type {?}
*/
NpImgUpload.prototype.label;
/**
* 是否禁用
* @type {?}
*/
NpImgUpload.prototype.isDisabled;
/**
* 是否忽略宽高检查，true - 忽略宽高检查，false - 检查宽高
* @type {?}
*/
NpImgUpload.prototype.ignoreWidthAndHeightCheck;
/**
* 是否必填 - 必填则有红色*号在标签前面；否则没有
* @type {?}
*/
NpImgUpload.prototype.isRequired;
/**
* 上传图片按钮文字
* @type {?}
*/
NpImgUpload.prototype.btnText;
/**
* 图片描述，如尺寸、格式、大小等
* @type {?}
*/
NpImgUpload.prototype.imgDesc;
/**
* 图片格式，默认jpg、png和jpeg
* @type {?}
*/
NpImgUpload.prototype.imgFormat;
/**
* 图片大小，默认最大500kb
* @type {?}
*/
NpImgUpload.prototype.maxSize;
/**
* 图片宽度px
* @type {?}
*/
NpImgUpload.prototype.width;
/**
* 图片高度px
* @type {?}
*/
NpImgUpload.prototype.height;
/**
* 错误信息 - 将以红色字体显示在上传按钮下方
* @type {?}
*/
NpImgUpload.prototype.errorMessage;
/**
* 当重新选择图片时触发
* @type {?}
*/
NpImgUpload.prototype.onImgFileChanged;
/**
* 上传错误，如尺寸不对、格式不对，大小不对等
* @type {?}
*/
NpImgUpload.prototype.onUploadError;
/**
* 点击缩略图是触发
* @type {?}
*/
NpImgUpload.prototype.onImgClicked;
/** @type {?} */
NpImgUpload.prototype.currentImgFile;
/** @type {?} */
NpImgUpload.prototype.currentImgSrc;
/**
* @type {?}
* @private
*/
NpImgUpload.prototype.sanitizer;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"img-upload.js","sourceRoot":"ng://ngx-pluto/","sources":["lib/img-upload/img-upload.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ViewEncapsulation, OnInit, Input, ElementRef, ViewChild, Output, EventEmitter, forwardRef } from \"@angular/core\";\r\nimport { DomSanitizer } from \"@angular/platform-browser\";\r\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor, NG_VALIDATORS, Validator, AbstractControl, ValidationErrors } from \"@angular/forms\";\r\nimport { Utils } from \"../common/utils\";\r\n\r\n/**\r\n * 图片上传组件 - 支持NgModel和reactive forms\r\n * \r\n * <example-url>https://stackblitz.com/edit/np-img-upload-sample?embed=1&file=src/app/app.component.html</example-url>\r\n */\r\n@Component({\r\n  selector: `np-img-upload`,\r\n  templateUrl: 'img-upload.html',\r\n  styleUrls: ['img-upload.scss'],\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => NpImgUpload),\r\n      multi: true,\r\n    },\r\n    {\r\n      provide: NG_VALIDATORS,\r\n      useExisting: forwardRef(() => NpImgUpload),\r\n      multi: true,\r\n    }],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\n\r\nexport class NpImgUpload implements OnInit, ControlValueAccessor, Validator {\r\n  private emitChange = (_: any) => { };\r\n\r\n  /**标签 */\r\n  @Input() label: string = '选择图片';\r\n\r\n  /**是否禁用 */\r\n  @Input() isDisabled: boolean;\r\n\r\n  /**是否忽略宽高检查，true - 忽略宽高检查，false - 检查宽高  */\r\n  @Input() ignoreWidthAndHeightCheck: boolean = false;\r\n\r\n  /**是否必填 - 必填则有红色*号在标签前面；否则没有 */\r\n  @Input() isRequired: boolean;\r\n\r\n  /**上传图片按钮文字 */\r\n  @Input() btnText: string = '点击上传';\r\n\r\n  /**图片描述，如尺寸、格式、大小等 */\r\n  @Input() imgDesc: string = '*图片描述，如尺寸、格式、大小等*';\r\n\r\n  /**图片格式，默认jpg、png和jpeg */\r\n  @Input() imgFormat: string = 'jpg|png|jpeg';\r\n\r\n  /**图片大小，默认最大500kb */\r\n  @Input() maxSize: number = 500;\r\n\r\n  /**图片宽度px */\r\n  @Input() width: number;\r\n\r\n  /**图片高度px */\r\n  @Input() height: number;\r\n\r\n  /**错误信息 - 将以红色字体显示在上传按钮下方 */\r\n  @Input() errorMessage: string;\r\n\r\n\r\n  /**当重新选择图片时触发 */\r\n  @Output() onImgFileChanged = new EventEmitter<any>();\r\n\r\n  /**上传错误，如尺寸不对、格式不对，大小不对等 */\r\n  @Output() onUploadError = new EventEmitter<string>();\r\n\r\n  /**点击缩略图是触发 */\r\n  @Output() onImgClicked = new EventEmitter<any>();\r\n\r\n  currentImgFile: File = null;\r\n  currentImgSrc: any = null;\r\n\r\n  constructor(private sanitizer: DomSanitizer) { }\r\n\r\n  ngOnInit() {\r\n\r\n  }\r\n\r\n  onCurrentImgFileChanged(file: File) {\r\n    const filename = file.name;\r\n    const reg = new RegExp(`\\.(${this.imgFormat.toLowerCase()})|.(${this.imgFormat.toUpperCase()})$`);\r\n    if (!reg.test(filename)) {\r\n      this.errorMessage = '图片格式不对，支持' + this.imgFormat.split('|').join('、');\r\n      this.onUploadError.next(this.errorMessage);\r\n      this.emitChange({ file: null, src: null });\r\n      return;\r\n    }\r\n\r\n    if (file.size > +this.maxSize * 1024) {\r\n      this.errorMessage = '图片大于' + this.maxSize + 'kb，请重新选择';\r\n      this.onUploadError.next(this.errorMessage);\r\n      this.emitChange({ file: null, src: null });\r\n      return;\r\n    }\r\n\r\n    Utils.checkImgWidthAndHeight(file, +this.width, +this.height).subscribe(res => {\r\n      if (!res && !this.ignoreWidthAndHeightCheck) {\r\n        this.errorMessage = '图片大小必须为' + this.width + '*' + this.height;\r\n        this.onUploadError.next(this.errorMessage);\r\n        this.emitChange({ file: null, src: null });\r\n        return;\r\n      }\r\n\r\n      this.errorMessage = '';\r\n      this.currentImgSrc = this.sanitizer.bypassSecurityTrustUrl(URL.createObjectURL(file));\r\n      this.currentImgFile = file;\r\n\r\n      this.emitChange({ file: this.currentImgFile, src: this.currentImgSrc });\r\n      this.onImgFileChanged.next({ file: this.currentImgFile, src: this.currentImgSrc });\r\n      return true;\r\n    });\r\n  }\r\n\r\n  onUploadImgFormatError(msg: string) {\r\n    this.errorMessage = '图片格式不对，支持' + this.imgFormat.split('|').join('、');\r\n    this.onUploadError.next(this.errorMessage);\r\n    this.emitChange({ file: null, src: null });\r\n  }\r\n\r\n  onCurrentImgClick() {\r\n    this.onImgClicked.next({file: this.currentImgFile, src: this.currentImgSrc});\r\n  }\r\n\r\n  writeValue(obj: any): void {\r\n    if (obj) {\r\n      this.currentImgFile = obj.file;\r\n      this.currentImgSrc = obj.src;\r\n    } else {\r\n      this.currentImgFile = null;\r\n      this.currentImgSrc = null;\r\n    }\r\n  }\r\n\r\n  validate(control: AbstractControl): ValidationErrors {\r\n    if (this.isRequired) {\r\n      if (control && control.value && !control.value.file && !control.value.src) {\r\n        return { 'imgError': true };\r\n      }\r\n\r\n      if (control && !control.value) {\r\n        return { 'imgError': true };\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  registerOnChange(fn: any): void {\r\n    this.emitChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any): void { }\r\n\r\n  setDisabledState?(isDisabled: boolean): void { }\r\n}"]}