@pobuca/email-builder 1.0.0

package/esm2015/lib/services/user-image-uploader-service/upload-bottom-sheet-dialog/upload-bottom-sheet-dialog.component.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Component, ViewChild, ElementRef } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Subject, EMPTY } from 'rxjs';
+import { HttpEventType, HttpResponse } from '@angular/common/http';
+import { MatBottomSheetRef } from '@angular/material/bottom-sheet';
+import { catchError, finalize, switchMap } from 'rxjs/operators';
+import { bytesToSize } from '../../../utils';
+import { PbEmailBuilderService } from '../../../pb-email-builder.service';
+import { PbUserMiddlewaresService } from '../../user-middleware-service/pb-middlewares.service';
+import { PbUserInterfaceService } from '../../internals/user-interfaces/user-interface.service';
+import { PbUserRestApiService } from '../../user-rest-api-service/user-rest-api.service';
+export class UploadBottomSheetDialogComponent {
+    constructor(sanitizer, ngb, userRestApi, userInterface, middlewares, bottomSheetRef) {
+        this.sanitizer = sanitizer;
+        this.ngb = ngb;
+        this.userRestApi = userRestApi;
+        this.userInterface = userInterface;
+        this.middlewares = middlewares;
+        this.bottomSheetRef = bottomSheetRef;
+        this.uploading = false;
+        this.progress = new Subject();
+    }
+    get imageInfo() {
+        if (this.choosedImage) {
+            const { lastModified, size } = this.choosedImage;
+            const modTime = new Date(lastModified);
+            return `${modTime.toLocaleString()}, ${bytesToSize(size)}.`;
+        }
+        return '';
+    }
+    previewLink() {
+        return this.sanitizer.bypassSecurityTrustResourceUrl(this.objectUrl);
+    }
+    openBrowserModal(event) {
+        event.preventDefault();
+        const { uploadImagePath } = this.ngb.config;
+        if (!this.uploading && uploadImagePath) {
+            this.uploadInput.nativeElement.click();
+        }
+        else if (!uploadImagePath) {
+            this.userInterface.notify(`Hm ... this isn't a bug, it seems 'uploadImagePath' is empty!`);
+        }
+    }
+    uploadInputChanged() {
+        const { nativeElement } = this.uploadInput;
+        if (nativeElement.files.length) {
+            this._startUploading(nativeElement.files.item(0));
+        }
+    }
+    _startUploading(image) {
+        if (this.objectUrl) {
+            URL.revokeObjectURL(this.objectUrl);
+        }
+        this.objectUrl = URL.createObjectURL(image);
+        this.uploading = true;
+        const { uploadImagePath, csrf } = this.ngb.config;
+        const formData = new FormData();
+        if (csrf) {
+            formData.append(csrf.name, csrf.token);
+        }
+        formData.append('image', image);
+        return this.userRestApi
+            .userImageUpload$(formData, uploadImagePath)
+            .pipe(catchError((error) => this.middlewares.catchError(error).pipe(switchMap(() => {
+            this.userInterface.notify(error.message);
+            return EMPTY;
+        }))), finalize(() => this.progress.complete()))
+            .subscribe((event) => {
+            if (event.type === HttpEventType.UploadProgress) {
+                const percentDone = Math.round((100 * event.loaded) / event.total);
+                this.progress.next(percentDone);
+            }
+            else if (event instanceof HttpResponse) {
+                if (!event.body.success) {
+                    this.userInterface.notify(event.body.message, 'Dismiss', null);
+                }
+                else {
+                    this.bottomSheetRef.dismiss(event.body.path);
+                    this.userInterface.notify('Successfully uploaded.', null, 1000);
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.objectUrl) {
+            URL.revokeObjectURL(this.objectUrl);
+        }
+    }
+}
+UploadBottomSheetDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-upload-bottom-sheet-dialog',
+                template: "<!--\n  ~ Copyright (c) 2024 Pobuca.\n  ~ All rights reserved.\n  -->\n\n<mat-nav-list>\n  <mat-list-item (click)=\"openBrowserModal($event)\">\n    <div *ngIf=\"!uploading\">\n      <span mat-line i18n=\"upload|Browse images from computer\">Browse images from computer</span>\n    </div>\n    <ng-container *ngIf=\"uploading\">\n      <img matListAvatar [src]=\"previewLink()\" />\n      <span mat-line i18n=\"upload|Uploading Message\">Uploading ...</span>\n      <span mat-line>{{ imageInfo }}</span>\n    </ng-container>\n  </mat-list-item>\n  <mat-progress-bar *ngIf=\"uploading\" mode=\"buffer\" [value]=\"progress | async\"></mat-progress-bar>\n</mat-nav-list>\n<input type=\"file\" accept=\"image/*\" fxHide #uploadInput (change)=\"uploadInputChanged()\" />\n",
+                styles: [""]
+            },] }
+];
+UploadBottomSheetDialogComponent.ctorParameters = () => [
+    { type: DomSanitizer },
+    { type: PbEmailBuilderService },
+    { type: PbUserRestApiService },
+    { type: PbUserInterfaceService },
+    { type: PbUserMiddlewaresService },
+    { type: MatBottomSheetRef }
+];
+UploadBottomSheetDialogComponent.propDecorators = {
+    uploadInput: [{ type: ViewChild, args: ['uploadInput', { static: true },] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-bottom-sheet-dialog.component.js","sourceRoot":"","sources":["../../../../../../../projects/pb-email-builder/src/lib/services/user-image-uploader-service/upload-bottom-sheet-dialog/upload-bottom-sheet-dialog.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { Component, ViewChild, ElementRef, OnDestroy } from '@angular/core';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { Subject, EMPTY } from 'rxjs';\nimport { HttpEventType, HttpResponse, HttpEvent, HttpErrorResponse } from '@angular/common/http';\nimport { MatBottomSheetRef } from '@angular/material/bottom-sheet';\nimport { catchError, finalize, switchMap } from 'rxjs/operators';\n\nimport { bytesToSize } from '../../../utils';\nimport { PbEmailBuilderService } from '../../../pb-email-builder.service';\nimport { PbUserMiddlewaresService } from '../../user-middleware-service/pb-middlewares.service';\nimport { PbUserInterfaceService } from '../../internals/user-interfaces/user-interface.service';\nimport { PbUserRestApiService } from '../../user-rest-api-service/user-rest-api.service';\n\n@Component({\n  selector: 'pb-upload-bottom-sheet-dialog',\n  templateUrl: './upload-bottom-sheet-dialog.component.html',\n  styleUrls: ['./upload-bottom-sheet-dialog.component.css']\n})\nexport class UploadBottomSheetDialogComponent implements OnDestroy {\n  @ViewChild('uploadInput', { static: true }) uploadInput: ElementRef<HTMLInputElement>;\n  choosedImage: File;\n  uploading = false;\n  progress = new Subject<number>();\n  private objectUrl: string;\n\n  constructor(\n    private sanitizer: DomSanitizer,\n    private ngb: PbEmailBuilderService,\n    private userRestApi: PbUserRestApiService,\n    private userInterface: PbUserInterfaceService,\n    private middlewares: PbUserMiddlewaresService,\n    private bottomSheetRef: MatBottomSheetRef<UploadBottomSheetDialogComponent>\n  ) {}\n\n  get imageInfo() {\n    if (this.choosedImage) {\n      const { lastModified, size } = this.choosedImage;\n      const modTime = new Date(lastModified);\n      return `${modTime.toLocaleString()}, ${bytesToSize(size)}.`;\n    }\n    return '';\n  }\n\n  previewLink() {\n    return this.sanitizer.bypassSecurityTrustResourceUrl(this.objectUrl);\n  }\n\n  openBrowserModal(event: MouseEvent) {\n    event.preventDefault();\n    const { uploadImagePath } = this.ngb.config;\n    if (!this.uploading && uploadImagePath) {\n      this.uploadInput.nativeElement.click();\n    } else if (!uploadImagePath) {\n      this.userInterface.notify(`Hm ... this isn't a bug, it seems 'uploadImagePath' is empty!`);\n    }\n  }\n\n  uploadInputChanged() {\n    const { nativeElement } = this.uploadInput;\n    if (nativeElement.files.length) {\n      this._startUploading(nativeElement.files.item(0));\n    }\n  }\n\n  private _startUploading(image: File) {\n    if (this.objectUrl) {\n      URL.revokeObjectURL(this.objectUrl);\n    }\n    this.objectUrl = URL.createObjectURL(image);\n    this.uploading = true;\n\n    const { uploadImagePath, csrf } = this.ngb.config;\n\n    const formData = new FormData();\n    if (csrf) {\n      formData.append(csrf.name, csrf.token);\n    }\n    formData.append('image', image);\n\n    return this.userRestApi\n      .userImageUpload$(formData, uploadImagePath)\n      .pipe(\n        catchError((error: Error | HttpErrorResponse) =>\n          this.middlewares.catchError(error).pipe(\n            switchMap(() => {\n              this.userInterface.notify(error.message);\n              return EMPTY;\n            })\n          )\n        ),\n        finalize(() => this.progress.complete())\n      )\n      .subscribe((event: HttpEvent<{ success: boolean; path: string; message?: string }>) => {\n        if (event.type === HttpEventType.UploadProgress) {\n          const percentDone = Math.round((100 * event.loaded) / event.total);\n          this.progress.next(percentDone);\n        } else if (event instanceof HttpResponse) {\n          if (!event.body.success) {\n            this.userInterface.notify(event.body.message, 'Dismiss', null);\n          } else {\n            this.bottomSheetRef.dismiss(event.body.path);\n            this.userInterface.notify('Successfully uploaded.', null, 1000);\n          }\n        }\n      });\n  }\n\n  ngOnDestroy() {\n    if (this.objectUrl) {\n      URL.revokeObjectURL(this.objectUrl);\n    }\n  }\n}\n"]}

package/esm2015/lib/services/user-image-uploader-service/upload-image-gallery/upload-image-gallery.component.js

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+import { DomSanitizer } from '@angular/platform-browser';
+import { catchError, switchMap } from 'rxjs/operators';
+import { HttpEventType, HttpResponse } from '@angular/common/http';
+import { EMPTY } from 'rxjs';
+import { PbUserRestApiService } from '../../user-rest-api-service/user-rest-api.service';
+import { PB_CONFIG } from '../../../tokens/tokens';
+import { PbUserMiddlewaresService } from '../../user-middleware-service/pb-middlewares.service';
+import { PbUserInterfaceService } from '../../internals/user-interfaces/user-interface.service';
+export class UploadImageGalleryComponent {
+    constructor(imageCategoryList, userConfig, matDialogRef, sanitizer, userRestApi, middlewares, userInterface) {
+        this.imageCategoryList = imageCategoryList;
+        this.userConfig = userConfig;
+        this.matDialogRef = matDialogRef;
+        this.sanitizer = sanitizer;
+        this.userRestApi = userRestApi;
+        this.middlewares = middlewares;
+        this.userInterface = userInterface;
+        this.currentMenuItem = 'gallery';
+    }
+    changeCurrentMenuItem(item) {
+        this.currentMenuItem = item;
+    }
+    addImageToTemplate(imagePath = this.choseImage) {
+        this.matDialogRef.close(imagePath);
+    }
+    previewImage({ target }) {
+        this.uploadImageFile = target.files.item(0);
+        if (this.imagePreviewObjectUrl) {
+            URL.revokeObjectURL(this.imagePreviewObjectUrl);
+        }
+        this.imagePreviewObjectUrl = URL.createObjectURL(this.uploadImageFile);
+        this.uploadImagePreview = this.sanitizer.bypassSecurityTrustResourceUrl(this.imagePreviewObjectUrl);
+    }
+    startUploading() {
+        const { csrf, uploadImagePath } = this.userConfig;
+        const formData = new FormData();
+        if (csrf) {
+            formData.append(csrf.name, csrf.token);
+        }
+        formData.append('image', this.uploadImageFile);
+        return this.userRestApi
+            .userImageUpload$(formData, uploadImagePath)
+            .pipe(catchError((error) => this.middlewares.catchError(error).pipe(switchMap(() => {
+            this.userInterface.notify(error.message);
+            return EMPTY;
+        }))))
+            .subscribe((event) => {
+            if (event.type === HttpEventType.UploadProgress) {
+                // const percentDone = Math.round((100 * event.loaded) / event.total);
+                // this.progress.next(percentDone);
+            }
+            else if (event instanceof HttpResponse) {
+                if (!event.body.success) {
+                    this.userInterface.notify(event.body.message, 'Dismiss', null);
+                }
+                else {
+                    this.addImageToTemplate(event.body.path);
+                    this.userInterface.notify('Successfully uploaded.', null, 1000);
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.imagePreviewObjectUrl) {
+            URL.revokeObjectURL(this.imagePreviewObjectUrl);
+        }
+    }
+}
+UploadImageGalleryComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-upload-image-gallery',
+                template: "<!--\n  ~ Copyright (c) 2024 Pobuca.\n  ~ All rights reserved.\n  -->\n\n<div fxLayout=\"column\" style=\"height: 100%;\">\n    <h2 mat-dialog-title i18n=\"image-gallery|Modal Image gallery header\">Image Gallery</h2>\n    <div class=\"mat-typography gallery-list-wrapper\" fxLayout fxLayoutGap=\"1rem\" fxFlex>\n        <mat-list fxFlex=\"200px\">\n            <mat-list-item (click)=\"changeCurrentMenuItem('gallery')\" [class.active]=\"currentMenuItem === 'gallery'\"\n                i18n=\"image-gallery|Image list\">\n                Gallery Image list\n            </mat-list-item>\n            <mat-list-item (click)=\"changeCurrentMenuItem('upload')\" [class.active]=\"currentMenuItem === 'upload'\"\n                i18n=\"image-gallery|Upload an image\">\n                Upload an image\n            </mat-list-item>\n        </mat-list>\n\n        <ng-container *ngIf=\"currentMenuItem === 'gallery'\">\n            <ng-container *ngIf=\"imageCategoryList.length;else emptyImageList\">\n                <cdk-virtual-scroll-viewport itemSize=\"150\" [minBufferPx]=\"150 * 10\" fxFlex\n                    class=\"gallery-list\">\n                    <div *cdkVirtualFor=\"let imagePath of imageCategoryList\" class=\"gallery-list-item\"\n                         (click)=\"choseImage = imagePath\" i18n-matTooltip=\"image-gallery|Click to choose message\"\n                         matTooltip=\"Click to choose\">\n                        <img [src]=\"imagePath\" />\n                    </div>\n                </cdk-virtual-scroll-viewport>\n            </ng-container>\n        </ng-container>\n        <ng-container *ngIf=\"currentMenuItem === 'upload'\">\n            <div class=\"upload-image\" fxLayout=\"column\" fxLayoutAlign=\"center center\" fxFlex fxLayoutGap=\"1rem\">\n                <label class=\"upload-image-item\" [class.empty]=\"!uploadImagePreview\">\n                    <div class=\"upload-image-item-overview\" fxLayout=\"column\" fxLayoutAlign=\"center center\">\n                        <mat-icon>backup</mat-icon>\n                    </div>\n                    <img class=\"upload-image-item-preview\" *ngIf=\"uploadImagePreview\" [src]=\"uploadImagePreview\" />\n                    <input type=\"file\" fxHide pattern=\"image/*\" (change)=\"previewImage($event)\">\n                </label>\n                <button mat-flat-button color=\"primary\" (click)=\"startUploading()\" i18n=\"image-gallery|Upload and insert into template\">\n                  Upload and insert into template\n                </button>\n            </div>\n        </ng-container>\n    </div>\n    <mat-dialog-actions align=\"end\">\n        <button mat-button mat-dialog-close i18n=\"actions|Undo\">Cancel</button>\n        <button mat-stroked-button color=\"primary\" [disabled]=\"!choseImage\" (click)=\"addImageToTemplate()\"\n                i18n=\"actions|Start\">\n            Add to template\n        </button>\n    </mat-dialog-actions>\n</div>\n\n\n<ng-template #emptyImageList>\n    <div fxFlex fxLayout=\"column\" fxLayoutAlign=\"center center\" class=\"empty-category-notification\">\n        <mat-icon>notifications</mat-icon>\n        <h2 i18n=\"image-gallery|Image list is empty message\">Image list is empty!</h2>\n    </div>\n</ng-template>\n",
+                styles: ["/*!\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */mat-list{background-color:#fff}mat-list mat-list-item{cursor:pointer}mat-list mat-list-item.active{background-color:#ccc}.gallery-list ::ng-deep .cdk-virtual-scroll-content-wrapper{display:grid;gap:.3rem;grid-template:auto/repeat(4,1fr)}.gallery-list-item{height:120px;background-color:#ccc;cursor:pointer}.gallery-list-item img{width:100%;height:100%;-o-object-fit:contain;object-fit:contain;-o-object-position:center;object-position:center}.upload-image-item{width:80%;height:200px;background-color:#ccc;position:relative;border-radius:3px;padding:1em;text-align:center}.upload-image-item.empty .upload-image-item-overview,.upload-image-item:hover .upload-image-item-overview{opacity:1}.upload-image-item-overview{opacity:0;position:absolute;top:0;bottom:0;left:0;right:0;cursor:pointer;transition:opacity .5s linear}.upload-image-item-overview mat-icon{height:50px;width:50px;font-size:50px}.upload-image-item-preview{max-height:100%}"]
+            },] }
+];
+UploadImageGalleryComponent.ctorParameters = () => [
+    { type: Array, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [PB_CONFIG,] }] },
+    { type: MatDialogRef },
+    { type: DomSanitizer },
+    { type: PbUserRestApiService },
+    { type: PbUserMiddlewaresService },
+    { type: PbUserInterfaceService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-image-gallery.component.js","sourceRoot":"","sources":["../../../../../../../projects/pb-email-builder/src/lib/services/user-image-uploader-service/upload-image-gallery/upload-image-gallery.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { Component, Inject, OnDestroy } from '@angular/core';\nimport { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';\nimport { SafeResourceUrl, DomSanitizer } from '@angular/platform-browser';\nimport { catchError, switchMap } from 'rxjs/operators';\nimport { HttpErrorResponse, HttpEvent, HttpEventType, HttpResponse } from '@angular/common/http';\nimport { EMPTY } from 'rxjs';\n\nimport { PbUserRestApiService } from '../../user-rest-api-service/user-rest-api.service';\nimport { PB_CONFIG } from '../../../tokens/tokens';\nimport { IForRootConf } from '../../../interfaces/interfaces';\nimport { PbUserMiddlewaresService } from '../../user-middleware-service/pb-middlewares.service';\nimport { PbUserInterfaceService } from '../../internals/user-interfaces/user-interface.service';\n\n@Component({\n  selector: 'pb-upload-image-gallery',\n  templateUrl: './upload-image-gallery.component.html',\n  styleUrls: ['./upload-image-gallery.component.scss']\n})\nexport class UploadImageGalleryComponent implements OnDestroy {\n  currentMenuItem: 'gallery' | 'upload' = 'gallery';\n  choseImage: string;\n  uploadImagePreview: SafeResourceUrl;\n  private imagePreviewObjectUrl: string;\n  private uploadImageFile: File;\n\n  constructor(\n    @Inject(MAT_DIALOG_DATA) public imageCategoryList: string[],\n    @Inject(PB_CONFIG) private userConfig: IForRootConf,\n    private matDialogRef: MatDialogRef<UploadImageGalleryComponent, string>,\n    private sanitizer: DomSanitizer,\n    private userRestApi: PbUserRestApiService,\n    private middlewares: PbUserMiddlewaresService,\n    private userInterface: PbUserInterfaceService\n  ) {}\n\n  changeCurrentMenuItem(item: 'gallery' | 'upload') {\n    this.currentMenuItem = item;\n  }\n\n  addImageToTemplate(imagePath = this.choseImage) {\n    this.matDialogRef.close(imagePath);\n  }\n\n  previewImage({ target }: Event) {\n    this.uploadImageFile = (target as HTMLInputElement).files.item(0);\n    if (this.imagePreviewObjectUrl) {\n      URL.revokeObjectURL(this.imagePreviewObjectUrl);\n    }\n    this.imagePreviewObjectUrl = URL.createObjectURL(this.uploadImageFile);\n    this.uploadImagePreview = this.sanitizer.bypassSecurityTrustResourceUrl(this.imagePreviewObjectUrl);\n  }\n\n  startUploading() {\n    const { csrf, uploadImagePath } = this.userConfig;\n    const formData = new FormData();\n    if (csrf) {\n      formData.append(csrf.name, csrf.token);\n    }\n    formData.append('image', this.uploadImageFile);\n    return this.userRestApi\n      .userImageUpload$(formData, uploadImagePath)\n      .pipe(\n        catchError((error: Error | HttpErrorResponse) =>\n          this.middlewares.catchError(error).pipe(\n            switchMap(() => {\n              this.userInterface.notify(error.message);\n              return EMPTY;\n            })\n          )\n        )\n      )\n      .subscribe((event: HttpEvent<{ success: boolean; path: string; message?: string }>) => {\n        if (event.type === HttpEventType.UploadProgress) {\n          // const percentDone = Math.round((100 * event.loaded) / event.total);\n          // this.progress.next(percentDone);\n        } else if (event instanceof HttpResponse) {\n          if (!event.body.success) {\n            this.userInterface.notify(event.body.message, 'Dismiss', null);\n          } else {\n            this.addImageToTemplate(event.body.path);\n            this.userInterface.notify('Successfully uploaded.', null, 1000);\n          }\n        }\n      });\n  }\n\n  ngOnDestroy() {\n    if (this.imagePreviewObjectUrl) {\n      URL.revokeObjectURL(this.imagePreviewObjectUrl);\n    }\n  }\n}\n"]}

package/esm2015/lib/services/user-image-uploader-service/user-image-uploader.service.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Injectable } from '@angular/core';
+/**
+ * A service that must be extended in case you want to rewrite the default
+ * uploading process. In case you have a Regular License, you'll get a simple upload
+ * service, for any other paid Licenses - you get an Image Gallery.
+ *
+ * It won't work if you have a Regular/Free License - you'll get an error on running the project,
+ * you need either an [Extended or Commercial License]{@link https://wlocalhost.org} key for this purpose.
+ *
+ * @example
+ * // Create a custom service
+ * class YourOwnUploaderService extends PbUserImageUploaderService {}
+ *
+ * // Rewrite it into AppModule
+ * { provide: PbUserImageUploaderService, useClass: YourOwnUploaderService }
+ */
+export class PbUserImageUploaderService {
+}
+PbUserImageUploaderService.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/user-middleware-service/FreeUsersMiddleware.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { iif, throwError } from 'rxjs';
+import { PbUserMiddlewaresService } from './pb-middlewares.service';
+import { deferOf } from '../../utils';
+/**
+ * @ignore
+ */
+const NOT_ALLOWED = 'This feature is disabled in free version.';
+/**
+ * @internal
+ */
+export default class FreeUsersMiddleware extends PbUserMiddlewaresService {
+    constructor() {
+        super();
+        // tslint:disable-next-line: no-console
+        console.warn('You use the Regular License of Angular Email Builder, some limitations are applied. More info on https://wlocalhost.org');
+    }
+    chooseTemplate() {
+        throw new Error(NOT_ALLOWED);
+    }
+    exportFile(type) {
+        return iif(() => type === 'json', deferOf(type), throwError(new Error(NOT_ALLOWED)));
+    }
+    importFile(file) {
+        return iif(() => file.type === 'application/json', deferOf(file), throwError(new Error(NOT_ALLOWED)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/user-middleware-service/PaidUsersMiddleware.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { PbUserMiddlewaresService } from './pb-middlewares.service';
+/**
+ * @internal
+ * No limitations are applied for Paid users
+ */
+export default class PaidUsersMiddleware extends PbUserMiddlewaresService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGFpZFVzZXJzTWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3BiLWVtYWlsLWJ1aWxkZXIvc3JjL2xpYi9zZXJ2aWNlcy91c2VyLW1pZGRsZXdhcmUtc2VydmljZS9QYWlkVXNlcnNNaWRkbGV3YXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRXBFOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sbUJBQW9CLFNBQVEsd0JBQXdCO0NBQUciLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDI0IFBvYnVjYS5cbiAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKi9cblxuaW1wb3J0IHsgUGJVc2VyTWlkZGxld2FyZXNTZXJ2aWNlIH0gZnJvbSAnLi9wYi1taWRkbGV3YXJlcy5zZXJ2aWNlJztcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqIE5vIGxpbWl0YXRpb25zIGFyZSBhcHBsaWVkIGZvciBQYWlkIHVzZXJzXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFBhaWRVc2Vyc01pZGRsZXdhcmUgZXh0ZW5kcyBQYlVzZXJNaWRkbGV3YXJlc1NlcnZpY2Uge31cbiJdfQ==

package/esm2015/lib/services/user-middleware-service/index.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import FreeUsersMiddleware from './FreeUsersMiddleware';
+import PaidUsersMiddleware from './PaidUsersMiddleware';
+export { FreeUsersMiddleware, PaidUsersMiddleware };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9wYi1lbWFpbC1idWlsZGVyL3NyYy9saWIvc2VydmljZXMvdXNlci1taWRkbGV3YXJlLXNlcnZpY2UvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsT0FBTyxtQkFBbUIsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLG1CQUFtQixNQUFNLHVCQUF1QixDQUFDO0FBRXhELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxtQkFBbUIsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAyNCBQb2J1Y2EuXG4gKiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICovXG5cbmltcG9ydCBGcmVlVXNlcnNNaWRkbGV3YXJlIGZyb20gJy4vRnJlZVVzZXJzTWlkZGxld2FyZSc7XG5pbXBvcnQgUGFpZFVzZXJzTWlkZGxld2FyZSBmcm9tICcuL1BhaWRVc2Vyc01pZGRsZXdhcmUnO1xuXG5leHBvcnQgeyBGcmVlVXNlcnNNaWRkbGV3YXJlLCBQYWlkVXNlcnNNaWRkbGV3YXJlIH07XG4iXX0=

package/esm2015/lib/services/user-middleware-service/pb-middlewares.service.js

@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Injectable } from '@angular/core';
+import { deferOf } from '../../utils';
+/**
+ * This service allows you to control all your users' abilities within this builder. Lets say you want to implement user Roles or just
+ * need to disable some functionality for certain users based on purchase plan or on something else. You can allow or disallow almost
+ * everything.
+ *
+ * All the methods must return an Observable, so, in my opinion, that's the best part of this service, you can either return an
+ * [EMPTY Observable]{@link https://rxjs.dev/api/index/const/EMPTY}, a modified object or an (Info Modal).pipe(mapTo(EMPTY)) - I think you
+ * got the idea.
+ *
+ * I recommend always using a Modal or a Toast for forbidden actions.
+ *
+ * It won't work if you have a Regular/Free License - you'll get an error on running the project,
+ * you need either an [Extended or Commercial License]{@link https://wlocalhost.org} key for this purpose.
+ *
+ * @example
+ * // Create a custom service
+ * class YourOwnMiddlewareService extends PbUserMiddlewaresService {}
+ *
+ * // Rewrite it into AppModule
+ * { provide: PbUserMiddlewaresService, useClass: YourOwnMiddlewareService }
+ */
+export class PbUserMiddlewaresService {
+    /**
+     * This method is called before sending the request to MJML Convertor. Use it to add some additional blocks or anything else to
+     * the PBEmail object.
+     * @param email PBEmail object that's being sent to MJML Convertor.
+     */
+    createHTMLTemplate(email) {
+        return deferOf(email);
+    }
+    /**
+     * Allow or Disallow preview window.
+     * @param state Coming Preview state
+     */
+    togglePreview(state) {
+        return deferOf(state);
+    }
+    /**
+     * Allow or Disallow preview devices.
+     * @param button Device's button that has been clicked
+     */
+    togglePreviewDevice(button) {
+        return deferOf(button.value);
+    }
+    /**
+     * Allow or disallow users to select certain templates based either on category or template object.
+     * @param category Template's category user has selected
+     * @param template Template user has selected
+     */
+    chooseTemplate(category, template) {
+        return deferOf({ category, template });
+    }
+    /**
+     * Allow, disallow or return the same path for all user's uploaded images.
+     * @param path Path of uploaded image
+     *
+     * @TODO Check if this middleware is being called before image has been uploaded
+     */
+    uploadImage(path) {
+        return deferOf(path);
+    }
+    /**
+     * Allow or disallow users to add blocks within email structures.
+     * @param event Event of dropped block
+     * @param column Column that block has been dropped
+     *
+     * @TODO add parent structure as a parameter
+     */
+    addBlock(event, column) {
+        return deferOf({ event, column });
+    }
+    /**
+     * Prevent user to edit blocks within email body.
+     * @param block Block that user intends to edit
+     */
+    editBlock(block) {
+        return deferOf(block);
+    }
+    /**
+     * Prevent user to remove blocks within email body.
+     * @param index Block's Index
+     * @param column Block's parent column
+     * @param block Block that user intends to remove
+     */
+    removeBlock(index, column, block) {
+        return deferOf({ index, column });
+    }
+    /**
+     * Prevent user to duplicate blocks within email body.
+     * @param index Block's Index
+     * @param column Block's parent column
+     * @param block Block that user intends to duplicate
+     */
+    duplicateBlock(index, column, block) {
+        return deferOf({ index, column, block });
+    }
+    /**
+     * Disable Drag and Drop certain blocks from Blocks list to Email body.
+     * Return TRUE to disable all blocks - no matter on block's data.
+     * @param block Block to allow or disallow from being dragged
+     */
+    disableBlockDragFromList(block) {
+        return deferOf(false);
+    }
+    /**
+     * Prevent users to sort blocks within email body.
+     * @param block Block that user intends to change the order
+     */
+    disableBlockDragWithinEmailBody(block) {
+        return deferOf(false);
+    }
+    /**
+     * Prevent user to add new structure.
+     * @param event Event of dropped structure
+     */
+    addStructure(event) {
+        return deferOf(event);
+    }
+    /**
+     * Prevent user to edit the structure.
+     * @param structure Structure that user intends to edit
+     */
+    editStructure(structure) {
+        return deferOf(structure);
+    }
+    /**
+     * Prevent user to remove the structure.
+     * @param index Index of the structure
+     * @param structure Structure that user intends to remove
+     */
+    removeStructure(index, structure) {
+        return deferOf(index);
+    }
+    /**
+     * Prevent user to duplicate the structure within email body.
+     * @param index Index of structure
+     * @param structure Structure that user intends to duplicate
+     */
+    duplicateStructure(index, structure) {
+        return deferOf(index);
+    }
+    /**
+     * Disable Drag and Drop certain structures from Structures list to Email body.
+     * Return TRUE to disable all structures.
+     * @param structure Structure to prevent from being dragged
+     */
+    disableStructureDragFromList(structure) {
+        return deferOf(false);
+    }
+    /**
+     * Allow or disallow users to sort structures within email body.
+     * @param structure Structure that user intends to change the order
+     */
+    disableStructureDragWithinEmailBody(structure) {
+        return deferOf(false);
+    }
+    /**
+     * I don't know why would you do that, but you can disable OnExit confirm modal.
+     * @param event Window [BeforeUnloadEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/BeforeUnloadEvent}
+     */
+    preventWindowExit(event) {
+        return deferOf(event);
+    }
+    /**
+     * Allow or disallow user to export certain types of file
+     * @param type Type that user intends to download
+     */
+    exportFile(type) {
+        return deferOf(type);
+    }
+    /**
+     * Allow or disallow user to import certain types of file
+     * @param file Web APIs [FILE]{@link https://developer.mozilla.org/en-US/docs/Web/API/File}
+     */
+    importFile(file) {
+        return deferOf(file);
+    }
+    /**
+     * Catch all errors within email editor, it might not work 100%, it's still on working process.
+     * @param error Throwable Error
+     */
+    catchError(error) {
+        return deferOf(error);
+    }
+}
+PbUserMiddlewaresService.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pb-middlewares.service.js","sourceRoot":"","sources":["../../../../../../projects/pb-email-builder/src/lib/services/user-middleware-service/pb-middlewares.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { Injectable } from '@angular/core';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';\nimport { MatButtonToggleChange } from '@angular/material/button-toggle';\nimport { Observable } from 'rxjs';\n\nimport { IStructure, IUserTemplate } from '../../interfaces/interfaces';\nimport { TBlocks } from '../../classes/Elements';\nimport { PBEmail } from '../../classes/DefaultEmail';\nimport { TPreviewDevice } from '../../components/preview.component';\nimport { deferOf } from '../../utils';\n\n/**\n * Email editor export file types.\n */\nexport type TExportType = 'html' | 'json' | 'mjml';\n\n/**\n * Email editor import file types. 'mjml' type is under development - don't use it yet.\n */\nexport type TImportType = 'json' | 'mjml';\n\n/**\n * Add new Structure within email body event\n */\nexport interface IAddStructureEvent extends CdkDragDrop<Set<IStructure>, Set<IStructure>> {\n  item: CdkDrag<IStructure>;\n}\n\n/**\n * Add new Block within structures' columns event\n */\nexport interface IAddBlockEvent extends CdkDragDrop<TBlocks[], TBlocks[]> {\n  item: CdkDrag<TBlocks>;\n}\n\n/**\n * Preview device buttons\n */\nexport interface IPreviewToggleButton extends MatButtonToggleChange {\n  value: TPreviewDevice;\n}\n\n/**\n * This service allows you to control all your users' abilities within this builder. Lets say you want to implement user Roles or just\n * need to disable some functionality for certain users based on purchase plan or on something else. You can allow or disallow almost\n * everything.\n *\n * All the methods must return an Observable, so, in my opinion, that's the best part of this service, you can either return an\n * [EMPTY Observable]{@link https://rxjs.dev/api/index/const/EMPTY}, a modified object or an (Info Modal).pipe(mapTo(EMPTY)) - I think you\n * got the idea.\n *\n * I recommend always using a Modal or a Toast for forbidden actions.\n *\n * It won't work if you have a Regular/Free License - you'll get an error on running the project,\n * you need either an [Extended or Commercial License]{@link https://wlocalhost.org} key for this purpose.\n *\n * @example\n * // Create a custom service\n * class YourOwnMiddlewareService extends PbUserMiddlewaresService {}\n *\n * // Rewrite it into AppModule\n * { provide: PbUserMiddlewaresService, useClass: YourOwnMiddlewareService }\n */\n@Injectable()\nexport abstract class PbUserMiddlewaresService {\n  /**\n   * This method is called before sending the request to MJML Convertor. Use it to add some additional blocks or anything else to\n   * the PBEmail object.\n   * @param email PBEmail object that's being sent to MJML Convertor.\n   */\n  createHTMLTemplate(email: PBEmail): Observable<PBEmail> {\n    return deferOf(email);\n  }\n\n  /**\n   * Allow or Disallow preview window.\n   * @param state Coming Preview state\n   */\n  togglePreview(state: boolean): Observable<boolean> {\n    return deferOf(state);\n  }\n\n  /**\n   * Allow or Disallow preview devices.\n   * @param button Device's button that has been clicked\n   */\n  togglePreviewDevice(button: IPreviewToggleButton): Observable<TPreviewDevice> {\n    return deferOf(button.value);\n  }\n\n  /**\n   * Allow or disallow users to select certain templates based either on category or template object.\n   * @param category Template's category user has selected\n   * @param template Template user has selected\n   */\n  chooseTemplate(category: string, template: IUserTemplate): Observable<{ category: string; template: IUserTemplate }> {\n    return deferOf({ category, template });\n  }\n\n  /**\n   * Allow, disallow or return the same path for all user's uploaded images.\n   * @param path Path of uploaded image\n   *\n   * @TODO Check if this middleware is being called before image has been uploaded\n   */\n  uploadImage(path: string): Observable<string> {\n    return deferOf(path);\n  }\n\n  /**\n   * Allow or disallow users to add blocks within email structures.\n   * @param event Event of dropped block\n   * @param column Column that block has been dropped\n   *\n   * @TODO add parent structure as a parameter\n   */\n  addBlock(event: IAddBlockEvent, column: TBlocks[]): Observable<{ column: TBlocks[]; event: IAddBlockEvent }> {\n    return deferOf({ event, column });\n  }\n\n  /**\n   * Prevent user to edit blocks within email body.\n   * @param block Block that user intends to edit\n   */\n  editBlock(block: TBlocks): Observable<TBlocks> {\n    return deferOf(block);\n  }\n\n  /**\n   * Prevent user to remove blocks within email body.\n   * @param index Block's Index\n   * @param column Block's parent column\n   * @param block Block that user intends to remove\n   */\n  removeBlock(index: number, column: TBlocks[], block: TBlocks): Observable<{ index: number; column: TBlocks[] }> {\n    return deferOf({ index, column });\n  }\n\n  /**\n   * Prevent user to duplicate blocks within email body.\n   * @param index Block's Index\n   * @param column Block's parent column\n   * @param block Block that user intends to duplicate\n   */\n  duplicateBlock(index: number, column: TBlocks[], block: TBlocks): Observable<{ index: number; column: TBlocks[]; block: TBlocks }> {\n    return deferOf({ index, column, block });\n  }\n\n  /**\n   * Disable Drag and Drop certain blocks from Blocks list to Email body.\n   * Return TRUE to disable all blocks - no matter on block's data.\n   * @param block Block to allow or disallow from being dragged\n   */\n  disableBlockDragFromList(block: TBlocks): Observable<boolean> {\n    return deferOf(false);\n  }\n\n  /**\n   * Prevent users to sort blocks within email body.\n   * @param block Block that user intends to change the order\n   */\n  disableBlockDragWithinEmailBody(block: TBlocks): Observable<boolean> {\n    return deferOf(false);\n  }\n\n  /**\n   * Prevent user to add new structure.\n   * @param event Event of dropped structure\n   */\n  addStructure(event: IAddStructureEvent): Observable<IAddStructureEvent> {\n    return deferOf(event);\n  }\n\n  /**\n   * Prevent user to edit the structure.\n   * @param structure Structure that user intends to edit\n   */\n  editStructure(structure: IStructure): Observable<IStructure> {\n    return deferOf(structure);\n  }\n\n  /**\n   * Prevent user to remove the structure.\n   * @param index Index of the structure\n   * @param structure Structure that user intends to remove\n   */\n  removeStructure(index: number, structure: IStructure): Observable<number> {\n    return deferOf(index);\n  }\n\n  /**\n   * Prevent user to duplicate the structure within email body.\n   * @param index Index of structure\n   * @param structure Structure that user intends to duplicate\n   */\n  duplicateStructure(index: number, structure: IStructure): Observable<number> {\n    return deferOf(index);\n  }\n\n  /**\n   * Disable Drag and Drop certain structures from Structures list to Email body.\n   * Return TRUE to disable all structures.\n   * @param structure Structure to prevent from being dragged\n   */\n  disableStructureDragFromList(structure: IStructure): Observable<boolean> {\n    return deferOf(false);\n  }\n\n  /**\n   * Allow or disallow users to sort structures within email body.\n   * @param structure Structure that user intends to change the order\n   */\n  disableStructureDragWithinEmailBody(structure: IStructure): Observable<boolean> {\n    return deferOf(false);\n  }\n\n  /**\n   * I don't know why would you do that, but you can disable OnExit confirm modal.\n   * @param event Window [BeforeUnloadEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/BeforeUnloadEvent}\n   */\n  preventWindowExit(event: BeforeUnloadEvent): Observable<BeforeUnloadEvent> {\n    return deferOf(event);\n  }\n\n  /**\n   * Allow or disallow user to export certain types of file\n   * @param type Type that user intends to download\n   */\n  exportFile(type: TExportType): Observable<TExportType> {\n    return deferOf(type);\n  }\n\n  /**\n   * Allow or disallow user to import certain types of file\n   * @param file Web APIs [FILE]{@link https://developer.mozilla.org/en-US/docs/Web/API/File}\n   */\n  importFile(file: File): Observable<File> {\n    return deferOf(file);\n  }\n\n  /**\n   * Catch all errors within email editor, it might not work 100%, it's still on working process.\n   * @param error Throwable Error\n   */\n  catchError(error: Error | HttpErrorResponse): Observable<Error | HttpErrorResponse> {\n    return deferOf(error);\n  }\n}\n"]}

package/esm2015/lib/services/user-rest-api-service/free-users-rest-api.service.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { PbUserRestApiService } from './user-rest-api.service';
+/**
+ * @internal
+ * The free User Rest API service for Regular license.
+ * No differences between other licenses for now, but might be in the future.
+ */
+export default class FreeUsersRestApi extends PbUserRestApiService {
+    constructor(http) {
+        super(http);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJlZS11c2Vycy1yZXN0LWFwaS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcGItZW1haWwtYnVpbGRlci9zcmMvbGliL3NlcnZpY2VzL3VzZXItcmVzdC1hcGktc2VydmljZS9mcmVlLXVzZXJzLXJlc3QtYXBpLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBR0gsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFL0Q7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sZ0JBQWlCLFNBQVEsb0JBQW9CO0lBQ2hFLFlBQVksSUFBZ0I7UUFDMUIsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAyNCBQb2J1Y2EuXG4gKiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICovXG5cbmltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBQYlVzZXJSZXN0QXBpU2VydmljZSB9IGZyb20gJy4vdXNlci1yZXN0LWFwaS5zZXJ2aWNlJztcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqIFRoZSBmcmVlIFVzZXIgUmVzdCBBUEkgc2VydmljZSBmb3IgUmVndWxhciBsaWNlbnNlLlxuICogTm8gZGlmZmVyZW5jZXMgYmV0d2VlbiBvdGhlciBsaWNlbnNlcyBmb3Igbm93LCBidXQgbWlnaHQgYmUgaW4gdGhlIGZ1dHVyZS5cbiAqL1xuZXhwb3J0IGRlZmF1bHQgY2xhc3MgRnJlZVVzZXJzUmVzdEFwaSBleHRlbmRzIFBiVXNlclJlc3RBcGlTZXJ2aWNlIHtcbiAgY29uc3RydWN0b3IoaHR0cDogSHR0cENsaWVudCkge1xuICAgIHN1cGVyKGh0dHApO1xuICB9XG59XG4iXX0=

package/esm2015/lib/services/user-rest-api-service/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import FreeUsersRestApi from './free-users-rest-api.service';
+export { FreeUsersRestApi };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9wYi1lbWFpbC1idWlsZGVyL3NyYy9saWIvc2VydmljZXMvdXNlci1yZXN0LWFwaS1zZXJ2aWNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sZ0JBQWdCLE1BQU0sK0JBQStCLENBQUM7QUFDN0QsT0FBTyxFQUFDLGdCQUFnQixFQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDI0IFBvYnVjYS5cbiAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKi9cblxuaW1wb3J0IEZyZWVVc2Vyc1Jlc3RBcGkgZnJvbSAnLi9mcmVlLXVzZXJzLXJlc3QtYXBpLnNlcnZpY2UnO1xuZXhwb3J0IHtGcmVlVXNlcnNSZXN0QXBpfTtcbiJdfQ==