@pobuca/email-builder 1.0.0

package/esm2015/lib/pb-email-builder.module.js

@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Inject, NgModule } from '@angular/core';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import { MatBottomSheet, MatBottomSheetModule } from '@angular/material/bottom-sheet';
+import { MatButtonModule } from '@angular/material/button';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatDialog, MatDialogModule } from '@angular/material/dialog';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { ResizableModule } from 'angular-resizable-element';
+import { FormsModule } from '@angular/forms';
+import { HTTP_INTERCEPTORS, HttpClient, HttpClientModule } from '@angular/common/http';
+import { CommonModule } from '@angular/common';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import 'quill';
+import { QUILL_CONFIG_TOKEN, QuillModule } from 'ngx-quill';
+import { ColorChromeModule } from 'ngx-color/chrome';
+import { PB_CONFIG, PB_TEMPLATES_TEMPORARY_STORAGE } from './tokens/tokens';
+import { StructureComponent } from './components/structure/structure.component';
+import { PbEmailBuilderComponent } from './pb-email-builder.component';
+import { DynamicComponentDirective } from './directives/dynamic-component.directive';
+import { ImageComponent } from './elements/image/image.component';
+import { TextElementComponent } from './elements/text-element/text-element.component';
+import { ButtonComponent } from './elements/button/button.component';
+import { DividerComponent } from './elements/divider/divider.component';
+import { SpacerComponent } from './elements/spacer/spacer.component';
+import { SocialComponent } from './elements/social/social.component';
+import { BuilderContainerComponent } from './components/builder-container/builder-container.component';
+import { FontStylesComponent } from './groups/font-styles';
+import { PaddingComponent } from './groups/padding';
+import { LineHeightComponent } from './groups/line-height';
+import { WidthHeightComponent } from './groups/width-height';
+import { BorderComponent } from './groups/border';
+import { ColorComponent } from './groups/color';
+import { LinkComponent } from './groups/link';
+import { AlignComponent } from './groups/align';
+import { DirectionComponent } from './groups/direction';
+import { BackRepatComponent } from './groups/back-repeat';
+import { ConfirmDialogComponent } from './components/dialog.component';
+import { PreviewTemplateComponent } from './components/preview.component';
+import { PbEmailBuilderService } from './pb-email-builder.service';
+import { BlockComponent } from './components/block/block.component';
+import { ImageUploadComponent } from './groups/upload-image';
+import { BlockSettingsComponent } from './components/block-settings/block-settings.component';
+import { StructureSettingsComponent } from './components/structure-settings/structure-settings.component';
+import { GeneralSettingsComponent } from './components/general-settings/general-settings.component';
+import { MarginComponent } from './groups/margin';
+import { TemplateListDialogComponent } from './components/template-list-dialog/template-list-dialog.component';
+import { GapsComponent } from './groups/gaps';
+import { SlugifyPipe } from './pipes/slugify.pipe';
+import { FreeUsersMiddleware, PaidUsersMiddleware } from './services/user-middleware-service';
+import { FreeUsersImageUploader, PaidUsersImageUploader } from './services/user-image-uploader-service';
+import { PbUserMiddlewaresService } from './services/user-middleware-service/pb-middlewares.service';
+import { PbUserImageUploaderService } from './services/user-image-uploader-service/user-image-uploader.service';
+import { IpInterceptorInterceptor } from './interceptors/pb-interceptor.interceptor';
+import { ImportDialogComponent } from './components/import-dialog/import-dialog.component';
+import { UploadBottomSheetDialogComponent } from './services/user-image-uploader-service/upload-bottom-sheet-dialog/upload-bottom-sheet-dialog.component';
+import { UploadImageGalleryComponent } from './services/user-image-uploader-service/upload-image-gallery/upload-image-gallery.component';
+import { LIBRARY_IS_PRO } from './tokens/private-tokens';
+import { PbUserInterfaceService } from './services/internals/user-interfaces/user-interface.service';
+import { PbEmailObjectStoreService } from './services/internals/pb-email-object-store/pb-email-object-store.service';
+import { FreeUsersRestApi } from './services/user-rest-api-service';
+import { FreeUsersPbStorage } from './services/pb-storage';
+import { PbStorageService } from './services/pb-storage/pb-storage.service';
+import { PbUserRestApiService } from './services/user-rest-api-service/user-rest-api.service';
+import { PortalModule } from '@angular/cdk/portal';
+import '@angular/localize/init';
+/**
+ * @internal
+ * @param http
+ */
+export function createCustomRestApiService(http) {
+    return new FreeUsersRestApi(http);
+}
+/**
+ * @internal
+ * @param libraryIsProEnv
+ */
+export function createUserMiddlewareService(libraryIsProEnv) {
+    if (!libraryIsProEnv) {
+        return new FreeUsersMiddleware();
+    }
+    else {
+        return new PaidUsersMiddleware();
+    }
+}
+/**
+ * @internal
+ * @param templateStorage
+ */
+export function createUsersIpStorage(templateStorage) {
+    return new FreeUsersPbStorage(templateStorage);
+}
+/**
+ * @internal
+ * @param libraryIsProEnv
+ * @param matBottomSheet
+ * @param matDialog
+ * @param userMiddleware
+ * @param userRestApi
+ */
+export function createUserUploaderService(libraryIsProEnv, matBottomSheet, matDialog, userMiddleware, userRestApi) {
+    if (!libraryIsProEnv) {
+        return new FreeUsersImageUploader(matBottomSheet, userMiddleware);
+    }
+    else {
+        return new PaidUsersImageUploader(matDialog, userMiddleware, userRestApi);
+    }
+}
+const ɵ0 = {
+    bounds: 'pb-builder-container',
+    theme: 'bubble',
+    format: 'html',
+    trackChanges: 'all',
+    suppressGlobalRegisterWarning: true
+};
+export class PbEmailBuilderModule {
+    constructor(pbMiddlewaresService, userImageUploader, libraryIsPro) {
+        if (!libraryIsPro && !(pbMiddlewaresService instanceof FreeUsersMiddleware)) {
+            throw new Error('Upgrade to an Extended or Commercial License to use Custom Middlewares.');
+        }
+        if (!libraryIsPro && !(userImageUploader instanceof FreeUsersImageUploader)) {
+            throw new Error('Upgrade to an Extended or Commercial License to use Custom Image Uploader.');
+        }
+    }
+    /**
+     * @deprecated use PbEmailBuilderModule.withConfig(userConfig) instead
+     * @internal
+     */
+    static forRoot(userConfig = {}) {
+        return PbEmailBuilderModule.withConfig(userConfig);
+    }
+    /**
+     * Import module with configurations
+     * @param userConfig Configurations
+     */
+    static withConfig(userConfig = {}) {
+        return {
+            ngModule: PbEmailBuilderModule,
+            providers: [
+                PbEmailBuilderService,
+                PbEmailObjectStoreService,
+                PbUserInterfaceService,
+                { provide: PB_CONFIG, useValue: userConfig },
+                {
+                    provide: PbUserMiddlewaresService,
+                    useFactory: createUserMiddlewareService,
+                    deps: [LIBRARY_IS_PRO]
+                },
+                {
+                    provide: PbStorageService,
+                    useFactory: createUsersIpStorage,
+                    deps: [PB_TEMPLATES_TEMPORARY_STORAGE]
+                },
+                {
+                    provide: PbUserImageUploaderService,
+                    useFactory: createUserUploaderService,
+                    deps: [LIBRARY_IS_PRO, MatBottomSheet, MatDialog, PbUserMiddlewaresService, PbUserRestApiService]
+                },
+                {
+                    provide: PbUserRestApiService,
+                    useFactory: createCustomRestApiService,
+                    deps: [HttpClient]
+                }
+            ]
+        };
+    }
+}
+PbEmailBuilderModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    HttpClientModule,
+                    QuillModule,
+                    FlexLayoutModule,
+                    DragDropModule,
+                    FormsModule,
+                    ColorChromeModule,
+                    MatButtonModule,
+                    MatIconModule,
+                    MatFormFieldModule,
+                    MatInputModule,
+                    MatTabsModule,
+                    MatSliderModule,
+                    MatSelectModule,
+                    MatSlideToggleModule,
+                    MatButtonToggleModule,
+                    MatDividerModule,
+                    MatTooltipModule,
+                    MatDialogModule,
+                    MatSnackBarModule,
+                    MatProgressBarModule,
+                    MatMenuModule,
+                    MatSidenavModule,
+                    MatToolbarModule,
+                    MatListModule,
+                    MatBottomSheetModule,
+                    MatDividerModule,
+                    MatExpansionModule,
+                    ResizableModule,
+                    ScrollingModule,
+                    PortalModule
+                ],
+                declarations: [
+                    PbEmailBuilderComponent,
+                    StructureComponent,
+                    BlockComponent,
+                    DynamicComponentDirective,
+                    PreviewTemplateComponent,
+                    TextElementComponent,
+                    ImageComponent,
+                    ButtonComponent,
+                    DividerComponent,
+                    SpacerComponent,
+                    SocialComponent,
+                    BuilderContainerComponent,
+                    FontStylesComponent,
+                    PaddingComponent,
+                    MarginComponent,
+                    GapsComponent,
+                    LineHeightComponent,
+                    WidthHeightComponent,
+                    BorderComponent,
+                    ColorComponent,
+                    LinkComponent,
+                    AlignComponent,
+                    DirectionComponent,
+                    BackRepatComponent,
+                    ConfirmDialogComponent,
+                    ImageUploadComponent,
+                    BlockSettingsComponent,
+                    StructureSettingsComponent,
+                    GeneralSettingsComponent,
+                    UploadBottomSheetDialogComponent,
+                    UploadImageGalleryComponent,
+                    TemplateListDialogComponent,
+                    SlugifyPipe,
+                    ImportDialogComponent
+                ],
+                exports: [PbEmailBuilderComponent, PreviewTemplateComponent, SlugifyPipe],
+                entryComponents: [
+                    TextElementComponent,
+                    ImageComponent,
+                    ButtonComponent,
+                    DividerComponent,
+                    SpacerComponent,
+                    SocialComponent,
+                    ConfirmDialogComponent,
+                    UploadBottomSheetDialogComponent,
+                    UploadImageGalleryComponent,
+                    TemplateListDialogComponent,
+                    ImportDialogComponent
+                ],
+                providers: [
+                    {
+                        provide: QUILL_CONFIG_TOKEN,
+                        useValue: ɵ0
+                    },
+                    { provide: HTTP_INTERCEPTORS, useClass: IpInterceptorInterceptor, multi: true },
+                    // { provide: PB_BLOCK_ELEMENT, useClass: TextBlock, multi: true },
+                    PbEmailBuilderService,
+                    PbEmailObjectStoreService,
+                    PbUserInterfaceService
+                ]
+            },] }
+];
+PbEmailBuilderModule.ctorParameters = () => [
+    { type: PbUserMiddlewaresService },
+    { type: PbUserImageUploaderService },
+    { type: Boolean, decorators: [{ type: Inject, args: [LIBRARY_IS_PRO,] }] }
+];
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pb-email-builder.module.js","sourceRoot":"","sources":["../../../../projects/pb-email-builder/src/lib/pb-email-builder.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { Inject, ModuleWithProviders, NgModule } from '@angular/core';\nimport { DragDropModule } from '@angular/cdk/drag-drop';\nimport { FlexLayoutModule } from '@angular/flex-layout';\nimport { MatBottomSheet, MatBottomSheetModule } from '@angular/material/bottom-sheet';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\nimport { MatDialog, MatDialogModule } from '@angular/material/dialog';\nimport { MatDividerModule } from '@angular/material/divider';\nimport { MatExpansionModule } from '@angular/material/expansion';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatListModule } from '@angular/material/list';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatSidenavModule } from '@angular/material/sidenav';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { MatSliderModule } from '@angular/material/slider';\nimport { MatSnackBarModule } from '@angular/material/snack-bar';\nimport { MatTabsModule } from '@angular/material/tabs';\nimport { MatToolbarModule } from '@angular/material/toolbar';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { ResizableModule } from 'angular-resizable-element';\nimport { FormsModule } from '@angular/forms';\nimport { HTTP_INTERCEPTORS, HttpClient, HttpClientModule } from '@angular/common/http';\nimport { CommonModule } from '@angular/common';\nimport { ScrollingModule } from '@angular/cdk/scrolling';\n\nimport 'quill';\nimport { QUILL_CONFIG_TOKEN, QuillModule } from 'ngx-quill';\nimport { ColorChromeModule } from 'ngx-color/chrome';\n\nimport { IForRootConf } from './interfaces/interfaces';\nimport { PB_CONFIG, PB_TEMPLATES_TEMPORARY_STORAGE } from './tokens/tokens';\nimport { StructureComponent } from './components/structure/structure.component';\nimport { PbEmailBuilderComponent } from './pb-email-builder.component';\nimport { DynamicComponentDirective } from './directives/dynamic-component.directive';\n\nimport { ImageComponent } from './elements/image/image.component';\nimport { TextElementComponent } from './elements/text-element/text-element.component';\nimport { ButtonComponent } from './elements/button/button.component';\nimport { DividerComponent } from './elements/divider/divider.component';\nimport { SpacerComponent } from './elements/spacer/spacer.component';\nimport { SocialComponent } from './elements/social/social.component';\n\nimport { BuilderContainerComponent } from './components/builder-container/builder-container.component';\nimport { FontStylesComponent } from './groups/font-styles';\nimport { PaddingComponent } from './groups/padding';\nimport { LineHeightComponent } from './groups/line-height';\nimport { WidthHeightComponent } from './groups/width-height';\nimport { BorderComponent } from './groups/border';\nimport { ColorComponent } from './groups/color';\nimport { LinkComponent } from './groups/link';\nimport { AlignComponent } from './groups/align';\nimport { DirectionComponent } from './groups/direction';\nimport { BackRepatComponent } from './groups/back-repeat';\nimport { ConfirmDialogComponent } from './components/dialog.component';\nimport { PreviewTemplateComponent } from './components/preview.component';\nimport { PbEmailBuilderService } from './pb-email-builder.service';\nimport { BlockComponent } from './components/block/block.component';\nimport { ImageUploadComponent } from './groups/upload-image';\nimport { BlockSettingsComponent } from './components/block-settings/block-settings.component';\nimport { StructureSettingsComponent } from './components/structure-settings/structure-settings.component';\nimport { GeneralSettingsComponent } from './components/general-settings/general-settings.component';\nimport { MarginComponent } from './groups/margin';\nimport { TemplateListDialogComponent } from './components/template-list-dialog/template-list-dialog.component';\nimport { GapsComponent } from './groups/gaps';\n\nimport { SlugifyPipe } from './pipes/slugify.pipe';\n\nimport { FreeUsersMiddleware, PaidUsersMiddleware } from './services/user-middleware-service';\nimport { FreeUsersImageUploader, PaidUsersImageUploader } from './services/user-image-uploader-service';\n\nimport { PbUserMiddlewaresService } from './services/user-middleware-service/pb-middlewares.service';\nimport { PbUserImageUploaderService } from './services/user-image-uploader-service/user-image-uploader.service';\n\nimport { IpInterceptorInterceptor } from './interceptors/pb-interceptor.interceptor';\nimport { ImportDialogComponent } from './components/import-dialog/import-dialog.component';\nimport { UploadBottomSheetDialogComponent } from './services/user-image-uploader-service/upload-bottom-sheet-dialog/upload-bottom-sheet-dialog.component';\nimport { UploadImageGalleryComponent } from './services/user-image-uploader-service/upload-image-gallery/upload-image-gallery.component';\n\nimport { LIBRARY_IS_PRO } from './tokens/private-tokens';\nimport { PbUserInterfaceService } from './services/internals/user-interfaces/user-interface.service';\nimport { PbEmailObjectStoreService } from './services/internals/pb-email-object-store/pb-email-object-store.service';\nimport { FreeUsersRestApi } from './services/user-rest-api-service';\nimport { FreeUsersPbStorage } from './services/pb-storage';\nimport { PbStorageService } from './services/pb-storage/pb-storage.service';\nimport { PbUserRestApiService } from './services/user-rest-api-service/user-rest-api.service';\n\nimport { PortalModule } from '@angular/cdk/portal';\nimport '@angular/localize/init';\n\n/**\n * @internal\n * @param http\n */\nexport function createCustomRestApiService(http: HttpClient) {\n  return new FreeUsersRestApi(http);\n}\n\n/**\n * @internal\n * @param libraryIsProEnv\n */\nexport function createUserMiddlewareService(libraryIsProEnv: boolean) {\n  if (!libraryIsProEnv) {\n    return new FreeUsersMiddleware();\n  } else {\n    return new PaidUsersMiddleware();\n  }\n}\n\n/**\n * @internal\n * @param templateStorage\n */\nexport function createUsersIpStorage(templateStorage: Storage) {\n  return new FreeUsersPbStorage(templateStorage);\n}\n\n/**\n * @internal\n * @param libraryIsProEnv\n * @param matBottomSheet\n * @param matDialog\n * @param userMiddleware\n * @param userRestApi\n */\nexport function createUserUploaderService(\n  libraryIsProEnv: boolean,\n  matBottomSheet: MatBottomSheet,\n  matDialog: MatDialog,\n  userMiddleware: PbUserMiddlewaresService,\n  userRestApi: PbUserRestApiService\n) {\n  if (!libraryIsProEnv) {\n    return new FreeUsersImageUploader(matBottomSheet, userMiddleware);\n  } else {\n    return new PaidUsersImageUploader(matDialog, userMiddleware, userRestApi);\n  }\n}\n\n@NgModule({\n  imports: [\n    CommonModule,\n    HttpClientModule,\n    QuillModule,\n    FlexLayoutModule,\n    DragDropModule,\n    FormsModule,\n    ColorChromeModule,\n    MatButtonModule,\n\n    MatIconModule,\n    MatFormFieldModule,\n    MatInputModule,\n    MatTabsModule,\n    MatSliderModule,\n    MatSelectModule,\n    MatSlideToggleModule,\n    MatButtonToggleModule,\n    MatDividerModule,\n    MatTooltipModule,\n    MatDialogModule,\n    MatSnackBarModule,\n    MatProgressBarModule,\n    MatMenuModule,\n    MatSidenavModule,\n    MatToolbarModule,\n    MatListModule,\n    MatBottomSheetModule,\n    MatDividerModule,\n    MatExpansionModule,\n    ResizableModule,\n    ScrollingModule,\n    PortalModule\n  ],\n  declarations: [\n    PbEmailBuilderComponent,\n    StructureComponent,\n    BlockComponent,\n    DynamicComponentDirective,\n    PreviewTemplateComponent,\n\n    TextElementComponent,\n    ImageComponent,\n    ButtonComponent,\n    DividerComponent,\n    SpacerComponent,\n    SocialComponent,\n\n    BuilderContainerComponent,\n    FontStylesComponent,\n    PaddingComponent,\n    MarginComponent,\n    GapsComponent,\n    LineHeightComponent,\n    WidthHeightComponent,\n    BorderComponent,\n    ColorComponent,\n    LinkComponent,\n    AlignComponent,\n    DirectionComponent,\n    BackRepatComponent,\n    ConfirmDialogComponent,\n    ImageUploadComponent,\n    BlockSettingsComponent,\n    StructureSettingsComponent,\n    GeneralSettingsComponent,\n    UploadBottomSheetDialogComponent,\n    UploadImageGalleryComponent,\n    TemplateListDialogComponent,\n    SlugifyPipe,\n    ImportDialogComponent\n  ],\n  exports: [PbEmailBuilderComponent, PreviewTemplateComponent, SlugifyPipe],\n  entryComponents: [\n    TextElementComponent,\n    ImageComponent,\n    ButtonComponent,\n    DividerComponent,\n    SpacerComponent,\n    SocialComponent,\n    ConfirmDialogComponent,\n    UploadBottomSheetDialogComponent,\n    UploadImageGalleryComponent,\n    TemplateListDialogComponent,\n    ImportDialogComponent\n  ],\n  providers: [\n    {\n      provide: QUILL_CONFIG_TOKEN,\n      useValue: {\n        bounds: 'pb-builder-container',\n        theme: 'bubble',\n        format: 'html',\n        trackChanges: 'all',\n        suppressGlobalRegisterWarning: true\n      }\n    },\n    { provide: HTTP_INTERCEPTORS, useClass: IpInterceptorInterceptor, multi: true },\n    // { provide: PB_BLOCK_ELEMENT, useClass: TextBlock, multi: true },\n    PbEmailBuilderService,\n    PbEmailObjectStoreService,\n    PbUserInterfaceService\n  ]\n})\nexport class PbEmailBuilderModule {\n  constructor(\n    pbMiddlewaresService: PbUserMiddlewaresService,\n    userImageUploader: PbUserImageUploaderService,\n    @Inject(LIBRARY_IS_PRO) libraryIsPro: boolean\n  ) {\n    if (!libraryIsPro && !(pbMiddlewaresService instanceof FreeUsersMiddleware)) {\n      throw new Error('Upgrade to an Extended or Commercial License to use Custom Middlewares.');\n    }\n    if (!libraryIsPro && !(userImageUploader instanceof FreeUsersImageUploader)) {\n      throw new Error('Upgrade to an Extended or Commercial License to use Custom Image Uploader.');\n    }\n  }\n\n  /**\n   * @deprecated use PbEmailBuilderModule.withConfig(userConfig) instead\n   * @internal\n   */\n  static forRoot(userConfig: IForRootConf = {}): ModuleWithProviders<PbEmailBuilderModule> {\n    return PbEmailBuilderModule.withConfig(userConfig);\n  }\n\n  /**\n   * Import module with configurations\n   * @param userConfig Configurations\n   */\n  static withConfig(userConfig: IForRootConf = {}): ModuleWithProviders<PbEmailBuilderModule> {\n    return {\n      ngModule: PbEmailBuilderModule,\n      providers: [\n        PbEmailBuilderService,\n        PbEmailObjectStoreService,\n        PbUserInterfaceService,\n        { provide: PB_CONFIG, useValue: userConfig },\n        {\n          provide: PbUserMiddlewaresService,\n          useFactory: createUserMiddlewareService,\n          deps: [LIBRARY_IS_PRO]\n        },\n        {\n          provide: PbStorageService,\n          useFactory: createUsersIpStorage,\n          deps: [PB_TEMPLATES_TEMPORARY_STORAGE]\n        },\n        {\n          provide: PbUserImageUploaderService,\n          useFactory: createUserUploaderService,\n          deps: [LIBRARY_IS_PRO, MatBottomSheet, MatDialog, PbUserMiddlewaresService, PbUserRestApiService]\n        },\n        {\n          provide: PbUserRestApiService,\n          useFactory: createCustomRestApiService,\n          deps: [HttpClient]\n        }\n      ]\n    };\n  }\n}\n"]}

package/esm2015/lib/pb-email-builder.service.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Injectable, Inject } from '@angular/core';
+import { EMPTY } from 'rxjs';
+import { catchError, switchMap, shareReplay, tap, finalize } from 'rxjs/operators';
+import { PB_CONFIG, PB_DEFAULT_CONFIG } from './tokens/tokens';
+import { PbEmailObjectStoreService } from './services/internals/pb-email-object-store/pb-email-object-store.service';
+import { PbUserMiddlewaresService } from './services/user-middleware-service/pb-middlewares.service';
+import { PbUserInterfaceService } from './services/internals/user-interfaces/user-interface.service';
+/**
+ * @deprecated Soon it will be removed
+ * @internal
+ */
+export class PbEmailBuilderService {
+    constructor(config, 
+    // @Inject(PB_GOOGLE_FONTS) private googleFonts: string[],
+    emailObjectStore, pbMiddleWares, pbUserInterface // private _http: HttpClient,
+    ) {
+        this.config = config;
+        this.emailObjectStore = emailObjectStore;
+        this.pbMiddleWares = pbMiddleWares;
+        this.pbUserInterface = pbUserInterface;
+        // private _template = new BehaviorSubject<string>('');
+        // private _mjml = new BehaviorSubject<string>('');
+        // private readonly _onSave$ = new Subject();
+        /**
+         * @deprecated Please use the new service "UserRestApiService" instead
+         */
+        this.modules = new Set();
+        /**
+         * @deprecated Please use the new service "UserRestApiService" instead
+         */
+        this.customTemplates = new Set();
+        /**
+         * @deprecated Please use the new service "UserRestApiService" instead
+         */
+        this._mergeTags = new Set();
+        this.onTemplateCreated$ = this.emailObjectStore.onTemplateCreated$.pipe(shareReplay());
+        /**
+         * @deprecated Use onTemplateCreated$ instead
+         */
+        this.onSave$ = this.onTemplateCreated$;
+        /**
+         * @deprecated Use isLoading$ instead
+         */
+        this.isLoading = this.pbUserInterface.activeMatProgress$.asObservable();
+        this.isLoading$ = this.pbUserInterface.activeMatProgress$.asObservable();
+        this.config = Object.assign(Object.assign({}, PB_DEFAULT_CONFIG), this.config);
+    }
+    /**
+     * Save current Email Template
+     */
+    createHTMLTemplate$() {
+        this.pbUserInterface.activeMatProgress$.next(true);
+        return this.emailObjectStore.createHTMLTemplate$().pipe(tap(() => this.pbUserInterface.activeMatProgress$.next(false)), catchError((error) => this.pbMiddleWares.catchError(error).pipe(switchMap(() => {
+            this.pbUserInterface.notify(error.message);
+            this.pbUserInterface.activeMatProgress$.next(false);
+            return EMPTY;
+        }))), finalize(() => this.pbUserInterface.activeMatProgress$.next(false)));
+    }
+    /**
+     *  @deprecated Please use ngb.createHTMLTemplate$() instead
+     */
+    saveEmail() {
+        return this.createHTMLTemplate$();
+    }
+    /**
+     * Get Email as object
+     */
+    get Email() {
+        return this.emailObjectStore.Email;
+    }
+    /**
+     * Set Email saved from database or created with new PBEmail()
+     */
+    set Email(newEmail) {
+        this.emailObjectStore.setEmail(newEmail);
+    }
+    /**
+     * @deprecated Use getTemplateAsObservable$() instead
+     */
+    get Template() {
+        return null;
+    }
+    /**
+     * Set HTML output
+     */
+    // set Template(template: string) {
+    //   this._template.next(template);
+    // }
+    /**
+     * @deprecated Use getMjmlAsObservable$() instead
+     */
+    get Mjml() {
+        return null;
+    }
+    /**
+     * Listen Email changes
+     */
+    getEmailAsObservable$() {
+        return this.emailObjectStore.emailAsObservable$;
+    }
+    /**
+     * Listen Template changes
+     */
+    getTemplateAsObservable$() {
+        return this.emailObjectStore.templateAsObservable$;
+    }
+    /**
+     * Listen MJML changes
+     */
+    getMjmlAsObservable$() {
+        return this.emailObjectStore.mjmlAsObservable$;
+    }
+    /**
+     * Listen Email and Template changes
+     * @deprecated Use onTemplateCreated$ instead
+     */
+    onChanges$() {
+        return this.onTemplateCreated$;
+    }
+}
+PbEmailBuilderService.decorators = [
+    { type: Injectable }
+];
+PbEmailBuilderService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [PB_CONFIG,] }] },
+    { type: PbEmailObjectStoreService },
+    { type: PbUserMiddlewaresService },
+    { type: PbUserInterfaceService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pb-email-builder.service.js","sourceRoot":"","sources":["../../../../projects/pb-email-builder/src/lib/pb-email-builder.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { Injectable, Inject } from '@angular/core';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { Observable, EMPTY } from 'rxjs';\nimport { catchError, switchMap, shareReplay, tap, finalize } from 'rxjs/operators';\n\nimport { IForRootConf, IUserModule, IUserTemplate } from './interfaces/interfaces';\nimport { PBEmail } from './classes/DefaultEmail';\n\nimport { PB_CONFIG, PB_DEFAULT_CONFIG } from './tokens/tokens';\nimport { PbEmailObjectStoreService } from './services/internals/pb-email-object-store/pb-email-object-store.service';\nimport { PbUserMiddlewaresService } from './services/user-middleware-service/pb-middlewares.service';\nimport { PbUserInterfaceService } from './services/internals/user-interfaces/user-interface.service';\n\n/**\n * @deprecated Soon it will be removed\n * @internal\n */\n@Injectable()\nexport class PbEmailBuilderService {\n  // private _template = new BehaviorSubject<string>('');\n  // private _mjml = new BehaviorSubject<string>('');\n  // private readonly _onSave$ = new Subject();\n\n  /**\n   * @deprecated Please use the new service \"UserRestApiService\" instead\n   */\n  public modules = new Set<IUserModule>();\n  /**\n   * @deprecated Please use the new service \"UserRestApiService\" instead\n   */\n  public readonly customTemplates = new Set<IUserTemplate>();\n  /**\n   * @deprecated Please use the new service \"UserRestApiService\" instead\n   */\n  private _mergeTags = new Set<string>();\n\n  public readonly onTemplateCreated$ = this.emailObjectStore.onTemplateCreated$.pipe(shareReplay());\n\n  /**\n   * @deprecated Use onTemplateCreated$ instead\n   */\n  public readonly onSave$ = this.onTemplateCreated$;\n\n  /**\n   * @deprecated Use isLoading$ instead\n   */\n  public readonly isLoading = this.pbUserInterface.activeMatProgress$.asObservable();\n  public readonly isLoading$ = this.pbUserInterface.activeMatProgress$.asObservable();\n\n  constructor(\n    @Inject(PB_CONFIG) public config: IForRootConf,\n    // @Inject(PB_GOOGLE_FONTS) private googleFonts: string[],\n    private emailObjectStore: PbEmailObjectStoreService,\n    private pbMiddleWares: PbUserMiddlewaresService,\n    private pbUserInterface: PbUserInterfaceService // private _http: HttpClient,\n  ) {\n    this.config = { ...PB_DEFAULT_CONFIG, ...this.config };\n  }\n\n  /**\n   * Save current Email Template\n   */\n  createHTMLTemplate$() {\n    this.pbUserInterface.activeMatProgress$.next(true);\n    return this.emailObjectStore.createHTMLTemplate$().pipe(\n      tap(() => this.pbUserInterface.activeMatProgress$.next(false)),\n      catchError((error: HttpErrorResponse) =>\n        this.pbMiddleWares.catchError(error).pipe(\n          switchMap(() => {\n            this.pbUserInterface.notify(error.message);\n            this.pbUserInterface.activeMatProgress$.next(false);\n            return EMPTY;\n          })\n        )\n      ),\n      finalize(() => this.pbUserInterface.activeMatProgress$.next(false))\n    );\n  }\n\n  /**\n   *  @deprecated Please use ngb.createHTMLTemplate$() instead\n   */\n  saveEmail() {\n    return this.createHTMLTemplate$();\n  }\n\n  /**\n   * Get Email as object\n   */\n  get Email() {\n    return this.emailObjectStore.Email;\n  }\n\n  /**\n   * Set Email saved from database or created with new PBEmail()\n   */\n  set Email(newEmail: PBEmail) {\n    this.emailObjectStore.setEmail(newEmail);\n  }\n\n  /**\n   * @deprecated Use getTemplateAsObservable$() instead\n   */\n  get Template() {\n    return null;\n  }\n  /**\n   * Set HTML output\n   */\n  // set Template(template: string) {\n  //   this._template.next(template);\n  // }\n\n  /**\n   * @deprecated Use getMjmlAsObservable$() instead\n   */\n  get Mjml() {\n    return null;\n  }\n\n  /**\n   * Listen Email changes\n   */\n  getEmailAsObservable$(): Observable<PBEmail> {\n    return this.emailObjectStore.emailAsObservable$;\n  }\n\n  /**\n   * Listen Template changes\n   */\n  getTemplateAsObservable$(): Observable<string> {\n    return this.emailObjectStore.templateAsObservable$;\n  }\n\n  /**\n   * Listen MJML changes\n   */\n  getMjmlAsObservable$() {\n    return this.emailObjectStore.mjmlAsObservable$;\n  }\n\n  /**\n   * Listen Email and Template changes\n   * @deprecated Use onTemplateCreated$ instead\n   */\n  onChanges$(): Observable<[PBEmail, string, string]> {\n    return this.onTemplateCreated$;\n  }\n\n  /**\n   * Get Set of Structures from aside\n   */\n  // getSideStructures(): Set<IStructure> {\n  //   return this._structures;\n  // }\n\n  /**\n   * Get Set of Blocks from aside\n   */\n  // getSideBlocks(): Set<TBlocks> {\n  //   return this._blocks;\n  // }\n\n  /**\n   * Get a Set of fonts family\n   */\n  // get Fonts(): IFontFamily {\n  //   return this._fontFamily;\n  // }\n  // set Fonts(fonts: IFontFamily) {\n  //   this._fontFamily = fonts;\n  // }\n\n  // get FallbackFonts(): IFontFamily {\n  //   return this._fallbackFamily;\n  // }\n  // set FallbackFonts(fonts: IFontFamily) {\n  //   this._fallbackFamily = fonts;\n  // }\n\n  /**\n   * @deprecated Please use the new service \"UserRestApiService\" instead\n   */\n  // get MergeTags(): Set<string> {\n  //   return this._mergeTags;\n  // }\n\n  // set MergeTags(tags: Set<string>) {\n  //   this._mergeTags = tags;\n  // }\n}\n"]}

package/esm2015/lib/pipes/slugify.pipe.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Pipe } from '@angular/core';
+/**
+ * @ignore
+ *
+ * Soon will be removed.
+ */
+export class SlugifyPipe {
+    transform(input) {
+        const trChars = {
+            áÁ: 'a',
+            éÉ: 'e',
+            íÍ: 'i',
+            óÓ: 'o',
+            úÚ: 'u',
+            ñÑ: 'n'
+        };
+        for (const key of Object.keys(trChars)) {
+            input = input.replace(new RegExp('[' + key + ']', 'g'), trChars[key]);
+        }
+        return input
+            .toString()
+            .toLowerCase()
+            .replace(/\s+/g, '-') // Replace spaces with -
+            .replace(/[^\w\-]+/g, '') // Remove all non-word chars
+            .replace(/\-\-+/g, '-') // Replace multiple - with single -
+            .replace(/^-+/, '') // Trim - from start of text
+            .replace(/-+$/, ''); // Trim - from end of text
+    }
+}
+SlugifyPipe.decorators = [
+    { type: Pipe, args: [{
+                name: 'slugify'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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