@pobuca/email-builder 1.0.0

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

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { map, shareReplay } from 'rxjs/operators';
+import { deferOf } from '../../utils';
+/**
+ * Default NGB ROOT API Path
+ */
+const NGB_HOST = 'https://ngb-api.wlocalhost.org/v1';
+/**
+ * The abstract service that must extend the user's custom REST API service.
+ * Contains all required properties needed within project.
+ *
+ * Rewrite the default methods/properties to get the desired data.
+ * We recommend using `shareReplay()` operator if it's just a simple static data.
+ *
+ * @example
+ * // Create a custom service
+ * class YourOwnRestApiService extends PbUserRestApiService {}
+ *
+ * // Rewrite it into AppModule
+ * { provide: PbUserRestApiService, useClass: YourOwnRestApiService }
+ */
+export class PbUserRestApiService {
+    constructor(http) {
+        this.http = http;
+        /**
+         * Get all user merge fields to inject into text editor.
+         */
+        this.getAllUserMergeFields$ = deferOf([]);
+        /**
+         * Get all Custom Modules to be included into Modules List.
+         * We're looking for someone who could create many modules to be included by default, if you feel you can help us, please leave a message!
+         */
+        this.getAllUserModules$ = deferOf([]);
+        /**
+         * Get all Predefined Templates and categories.
+         * You can leave it to get all default templates from NGB API
+         */
+        this.getAllUserTemplates$ = this.http
+            .get(NGB_HOST.concat('/templates'))
+            .pipe(map(list => list.map(({ category, templates }) => ({
+            category,
+            templates: templates.map(title => ({
+                thumbPath: `https://ngb-templates.s3.amazonaws.com/${category}-${title}.jpg`,
+                title,
+                templateData: null
+            }))
+        }))), shareReplay());
+    }
+    /**
+     * This method must return the chosen template from Template Gallery List PBEmail object,
+     * see {@link PbUserRestApiService#getAllUserTemplates$|getAllUserTemplates$}.
+     *
+     * Sometimes it can contain 'templateData' property - in this case, just return it.
+     *
+     * @param category Selected Category from Template Gallery.
+     * @param template Selected Template from Template Gallery.
+     *
+     * @example
+     * if (template.templateData) { return template }
+     */
+    getUserTemplateData$(category, template) {
+        if (template.templateData) {
+            return deferOf(template);
+        }
+        return this.http
+            .get(NGB_HOST.concat('/templates'), {
+            params: { category, template: template.title }
+        })
+            .pipe(map(email => (Object.assign(Object.assign({}, template), { templateData: email }))));
+    }
+    /**
+     * Handle all uploaded images.
+     * FormData 'csrf' is deprecated in favor of [HttpClientXsrfModule]{@link https://angular.io/api/common/http/HttpClientXsrfModule}.
+     *
+     * @param body A FormData that contains 'image' and 'csrf' data.
+     * @param uploadImagePath Define a path where NGB have to send the upload request.
+     */
+    userImageUpload$(body, uploadImagePath) {
+        return this.http.request('POST', uploadImagePath, {
+            body,
+            reportProgress: true,
+            responseType: 'json',
+            observe: 'events'
+        });
+    }
+    /**
+     * Get all images to include into Image Gallery.
+     */
+    getUserImages$() {
+        return deferOf([]);
+    }
+    /**
+     * Rewrite the default request which converts PBEmail to HTML, if you have a paid License,
+     * this method allows you to rewrite the default Convertor API Path to yours.
+     *
+     * You can still use the default Convertor API Path, since you have a valid and active License Key.
+     *
+     * @param emailAndFonts PBEmail plus Google Fonts List object.
+     * @param url Your own Convertor API Path, or leave it empty to use NGB servers.
+     */
+    createHTMLTemplate$(emailAndFonts, url = NGB_HOST) {
+        return this.http.post(url, emailAndFonts);
+    }
+}
+PbUserRestApiService.decorators = [
+    { type: Injectable }
+];
+PbUserRestApiService.ctorParameters = () => [
+    { type: HttpClient }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-rest-api.service.js","sourceRoot":"","sources":["../../../../../../projects/pb-email-builder/src/lib/services/user-rest-api-service/user-rest-api.service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAa,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAIlD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAUtC;;GAEG;AACH,MAAM,QAAQ,GAAG,mCAAmC,CAAC;AAErD;;;;;;;;;;;;;GAaG;AAEH,MAAM,OAAgB,oBAAoB;IAgCxC,YAAmB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;QA/BnC;;WAEG;QACH,2BAAsB,GAAyB,OAAO,CAAW,EAAE,CAAC,CAAC;QAErE;;;WAGG;QACH,uBAAkB,GAA8B,OAAO,CAAgB,EAAE,CAAC,CAAC;QAE3E;;;WAGG;QACH,yBAAoB,GAAwC,IAAI,CAAC,IAAI;aAClE,GAAG,CAA8C,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;aAC/E,IAAI,CACH,GAAG,CAAC,IAAI,CAAC,EAAE,CACT,IAAI,CAAC,GAAG,CAAwB,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;YAC5D,QAAQ;YACR,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACjC,SAAS,EAAE,0CAA0C,QAAQ,IAAI,KAAK,MAAM;gBAC5E,KAAK;gBACL,YAAY,EAAE,IAAI;aACnB,CAAC,CAAC;SACJ,CAAC,CAAC,CACJ,EACD,WAAW,EAAE,CACd,CAAC;IAEkC,CAAC;IAEvC;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,QAAgB,EAAE,QAAuB;QAC5D,IAAI,QAAQ,CAAC,YAAY,EAAE;YACzB,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC;SAC1B;QACD,OAAO,IAAI,CAAC,IAAI;aACb,GAAG,CAAW,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;YAC5C,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK,EAAE;SAC/C,CAAC;aACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,iCAAM,QAAQ,KAAE,YAAY,EAAE,KAAK,IAAG,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;OAMG;IACH,gBAAgB,CAAC,IAAc,EAAE,eAAuB;QACtD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,eAAe,EAAE;YAChD,IAAI;YACJ,cAAc,EAAE,IAAI;YACpB,YAAY,EAAE,MAAM;YACpB,OAAO,EAAE,QAAQ;SAClB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,OAAO,CAAW,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;OAQG;IACH,mBAAmB,CAAC,aAAmC,EAAE,MAAc,QAAQ;QAC7E,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAsB,GAAG,EAAE,aAAa,CAAC,CAAC;IACjE,CAAC;;;YA5FF,UAAU;;;YAnCF,UAAU","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { Injectable } from '@angular/core';\nimport { HttpClient, HttpEvent } from '@angular/common/http';\nimport { Observable } from 'rxjs';\nimport { map, shareReplay } from 'rxjs/operators';\n\nimport { IPBEmail, IMjmlServerResponse, IUserModule, IUserTemplate, IUserTemplateCategory } from '../../interfaces/interfaces';\nimport { PBEmail } from '../../classes/DefaultEmail';\nimport { deferOf } from '../../utils';\n\n/**\n * Add Google Fonts list to PBEmail object to include into template.\n * MJML Convertor will filter and remove fonts that aren't used.\n */\nexport interface IEmailAndGoogleFonts extends PBEmail {\n  googleFonts: string[];\n}\n\n/**\n * Default NGB ROOT API Path\n */\nconst NGB_HOST = 'https://ngb-api.wlocalhost.org/v1';\n\n/**\n * The abstract service that must extend the user's custom REST API service.\n * Contains all required properties needed within project.\n *\n * Rewrite the default methods/properties to get the desired data.\n * We recommend using `shareReplay()` operator if it's just a simple static data.\n *\n * @example\n * // Create a custom service\n * class YourOwnRestApiService extends PbUserRestApiService {}\n *\n * // Rewrite it into AppModule\n * { provide: PbUserRestApiService, useClass: YourOwnRestApiService }\n */\n@Injectable()\nexport abstract class PbUserRestApiService {\n  /**\n   * Get all user merge fields to inject into text editor.\n   */\n  getAllUserMergeFields$: Observable<string[]> = deferOf<string[]>([]);\n\n  /**\n   * Get all Custom Modules to be included into Modules List.\n   * We're looking for someone who could create many modules to be included by default, if you feel you can help us, please leave a message!\n   */\n  getAllUserModules$: Observable<IUserModule[]> = deferOf<IUserModule[]>([]);\n\n  /**\n   * Get all Predefined Templates and categories.\n   * You can leave it to get all default templates from NGB API\n   */\n  getAllUserTemplates$: Observable<IUserTemplateCategory[]> = this.http\n    .get<{ category: string; templates: string[] }[]>(NGB_HOST.concat('/templates'))\n    .pipe(\n      map(list =>\n        list.map<IUserTemplateCategory>(({ category, templates }) => ({\n          category,\n          templates: templates.map(title => ({\n            thumbPath: `https://ngb-templates.s3.amazonaws.com/${category}-${title}.jpg`,\n            title,\n            templateData: null\n          }))\n        }))\n      ),\n      shareReplay()\n    );\n\n  constructor(public http: HttpClient) {}\n\n  /**\n   * This method must return the chosen template from Template Gallery List PBEmail object,\n   * see {@link PbUserRestApiService#getAllUserTemplates$|getAllUserTemplates$}.\n   *\n   * Sometimes it can contain 'templateData' property - in this case, just return it.\n   *\n   * @param category Selected Category from Template Gallery.\n   * @param template Selected Template from Template Gallery.\n   *\n   * @example\n   * if (template.templateData) { return template }\n   */\n  getUserTemplateData$(category: string, template: IUserTemplate): Observable<IUserTemplate> {\n    if (template.templateData) {\n      return deferOf(template);\n    }\n    return this.http\n      .get<IPBEmail>(NGB_HOST.concat('/templates'), {\n        params: { category, template: template.title }\n      })\n      .pipe(map(email => ({ ...template, templateData: email })));\n  }\n\n  /**\n   * Handle all uploaded images.\n   * FormData 'csrf' is deprecated in favor of [HttpClientXsrfModule]{@link https://angular.io/api/common/http/HttpClientXsrfModule}.\n   *\n   * @param body A FormData that contains 'image' and 'csrf' data.\n   * @param uploadImagePath Define a path where NGB have to send the upload request.\n   */\n  userImageUpload$(body: FormData, uploadImagePath: string): Observable<HttpEvent<{ success: boolean; path: string; message?: string }>> {\n    return this.http.request('POST', uploadImagePath, {\n      body,\n      reportProgress: true,\n      responseType: 'json',\n      observe: 'events'\n    });\n  }\n\n  /**\n   * Get all images to include into Image Gallery.\n   */\n  getUserImages$(): Observable<string[]> {\n    return deferOf<string[]>([]);\n  }\n\n  /**\n   * Rewrite the default request which converts PBEmail to HTML, if you have a paid License,\n   * this method allows you to rewrite the default Convertor API Path to yours.\n   *\n   * You can still use the default Convertor API Path, since you have a valid and active License Key.\n   *\n   * @param emailAndFonts PBEmail plus Google Fonts List object.\n   * @param url Your own Convertor API Path, or leave it empty to use NGB servers.\n   */\n  createHTMLTemplate$(emailAndFonts: IEmailAndGoogleFonts, url: string = NGB_HOST): Observable<IMjmlServerResponse> {\n    return this.http.post<IMjmlServerResponse>(url, emailAndFonts);\n  }\n}\n"]}

package/esm2015/lib/tokens/private-tokens.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { inject, InjectionToken } from '@angular/core';
+import { PB_CONFIG, PB_DEFAULT_CONFIG } from './tokens';
+/**
+ * @internal
+ */
+export const LIBRARY_IS_PRO = new InjectionToken('Library environment', {
+    providedIn: 'any',
+    factory: () => {
+        const { xApiKey } = inject(PB_CONFIG);
+        return !(!xApiKey || xApiKey.length < 40 || xApiKey === PB_DEFAULT_CONFIG.xApiKey);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS10b2tlbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9wYi1lbWFpbC1idWlsZGVyL3NyYy9saWIvdG9rZW5zL3ByaXZhdGUtdG9rZW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sRUFBRSxNQUFNLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZELE9BQU8sRUFBRSxTQUFTLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFeEQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsSUFBSSxjQUFjLENBQVUscUJBQXFCLEVBQUU7SUFDL0UsVUFBVSxFQUFFLEtBQUs7SUFDakIsT0FBTyxFQUFFLEdBQUcsRUFBRTtRQUNaLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDdEMsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLE1BQU0sR0FBRyxFQUFFLElBQUksT0FBTyxLQUFLLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3JGLENBQUM7Q0FDRixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDI0IFBvYnVjYS5cbiAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKi9cblxuaW1wb3J0IHsgaW5qZWN0LCBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBQQl9DT05GSUcsIFBCX0RFRkFVTFRfQ09ORklHIH0gZnJvbSAnLi90b2tlbnMnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgY29uc3QgTElCUkFSWV9JU19QUk8gPSBuZXcgSW5qZWN0aW9uVG9rZW48Ym9vbGVhbj4oJ0xpYnJhcnkgZW52aXJvbm1lbnQnLCB7XG4gIHByb3ZpZGVkSW46ICdhbnknLFxuICBmYWN0b3J5OiAoKSA9PiB7XG4gICAgY29uc3QgeyB4QXBpS2V5IH0gPSBpbmplY3QoUEJfQ09ORklHKTtcbiAgICByZXR1cm4gISgheEFwaUtleSB8fCB4QXBpS2V5Lmxlbmd0aCA8IDQwIHx8IHhBcGlLZXkgPT09IFBCX0RFRkFVTFRfQ09ORklHLnhBcGlLZXkpO1xuICB9XG59KTtcbiJdfQ==

package/esm2015/lib/tokens/tokens.js

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { InjectionToken } from '@angular/core';
+import { Structure } from '../classes/Structure';
+import { ButtonBlock, DividerBlock, ImageBlock, SocialBlock, SpacerBlock, TextBlock } from '../classes/Elements';
+/**
+ * Some top documentation
+ */
+/**
+ * The default social networks list provided by builder. This list is injected by {@link PB_SOCIAL_NETWORKS}.
+ */
+export const PB_DEFAULT_SOCIAL_NETWORKS = [
+    'github',
+    'instagram',
+    'web',
+    'snapchat',
+    'youtube',
+    'vimeo',
+    'medium',
+    'soundcloud',
+    'dribbble',
+    'facebook',
+    'twitter',
+    'pinterest',
+    'linkedin',
+    'tumblr',
+    'xing',
+    'tiktok'
+];
+/**
+ * The token that injects [default social networks list]{@link PB_DEFAULT_SOCIAL_NETWORKS}.
+ * Use it to add or remove social networks within list.
+ *
+ * @example
+ * {provide: PB_SOCIAL_NETWORKS, useValue: PB_DEFAULT_SOCIAL_NETWORKS.filter(network => !['github', 'instagram'].includes(network)}
+ */
+export const PB_SOCIAL_NETWORKS = new InjectionToken('PB Social Networks', {
+    providedIn: 'any',
+    factory: () => PB_DEFAULT_SOCIAL_NETWORKS
+});
+/**
+ * The default [Google Fonts]{@link https://fonts.google.com} list provided by builder.
+ * This list is injected by {@link PB_GOOGLE_FONTS} token.
+ */
+export const PB_DEFAULT_GOOGLE_FONTS = [
+    'Open+Sans:300,400,500,700',
+    'Droid+Sans:300,400,500,700',
+    'Lato:300,400,500,700',
+    'Roboto:300,400,700,900',
+    'Ubuntu:300,400,500,700',
+    'Fira+Sans:300,400,500,700',
+    'Mansalva:400'
+];
+/**
+ * The token that injects [default google fonts]{@link PB_DEFAULT_GOOGLE_FONTS} list.
+ */
+export const PB_GOOGLE_FONTS = new InjectionToken('PB Google Fonts', {
+    providedIn: 'any',
+    factory: () => PB_DEFAULT_GOOGLE_FONTS
+});
+/**
+ * The default Fallback Fonts list provided by builder. This list is injected by {@link PB_FALLBACK_FONTS} token.
+ *
+ * A fallback font is a font that takes effect in case a [Google Font]{@link PB_DEFAULT_GOOGLE_FONTS} can't be loaded by some email
+ * providers.
+ */
+export const PB_DEFAULT_FALLBACK_FONTS = [
+    'Palatino Linotype, Book Antiqua, Palatino, serif',
+    'Times New Roman, Times, serif',
+    'Arial, Helvetica, sans-serif',
+    'Arial Black, Gadget, sans-serif',
+    'Comic Sans MS, cursive, sans-serif',
+    'Impact, Charcoal, sans-serif',
+    'Lucida Sans Unicode, Lucida Grande, sans-serif',
+    'Tahoma, Geneva, sans-serif',
+    'Trebuchet MS, Helvetica, sans-serif',
+    'Verdana, Geneva, sans-serif',
+    'Courier New, Courier, monospace',
+    'Lucida Console, Monaco, monospace'
+];
+/**
+ * The token that injects {@link PB_DEFAULT_FALLBACK_FONTS} list.
+ */
+export const PB_FALLBACK_FONTS = new InjectionToken('PB Fallback Fonts', {
+    providedIn: 'any',
+    factory: () => PB_DEFAULT_FALLBACK_FONTS
+});
+/**
+ * The default [Structures]{@link IStructure} list. This list is injected by {@link PB_STRUCTURES} token.
+ */
+export const PB_DEFAULT_STRUCTURES = [
+    new Structure('cols_1'),
+    new Structure('cols_2'),
+    new Structure('cols_3'),
+    new Structure('cols_4'),
+    new Structure('cols_12'),
+    new Structure('cols_21')
+];
+/**
+ * The token that injects {@link PB_DEFAULT_STRUCTURES} list.
+ */
+export const PB_STRUCTURES = new InjectionToken('PB Structures', {
+    providedIn: 'any',
+    factory: () => PB_DEFAULT_STRUCTURES
+});
+/**
+ * The default [Blocks]{@link TBlocks} list. This list is injected by {@link PB_BLOCKS} token.
+ */
+export const PB_DEFAULT_BLOCKS = [
+    new TextBlock(),
+    new ImageBlock(),
+    new ButtonBlock(),
+    new DividerBlock(),
+    new SpacerBlock(),
+    new SocialBlock()
+];
+/**
+ * The token that injects {@link PB_BLOCKS} list.
+ */
+export const PB_BLOCKS = new InjectionToken('PB Blocks', {
+    providedIn: 'any',
+    factory: () => PB_DEFAULT_BLOCKS
+});
+/**
+ * Default builder configuration, injected by {@link PB_CONFIG} token. See {@link IForRootConf} for more info.
+ */
+export const PB_DEFAULT_CONFIG = Object.freeze({
+    xApiKey: 't7HdQfZjGp6R96fOV4P8v18ggf6LLTQZ1puUI2tz',
+    // apiPath: 'https://ngb-api.wlocalhost.org/v1',
+    useSaveButton: true,
+    usePreviewButton: true,
+    useDownloadButton: true,
+    templateListIfEmpty: true,
+    uploadImageName: 'image'
+});
+/**
+ * The token that injects [default builder configurations]{@link PB_DEFAULT_CONFIG}.
+ */
+export const PB_CONFIG = new InjectionToken('PB Builder Configuration', {
+    providedIn: 'root',
+    factory: () => PB_DEFAULT_CONFIG
+});
+/**
+ * The default Storage used by builder. It can be either `localStorage` or `sessionStorage`.
+ */
+export const PB_STORAGE_FACTORY = new InjectionToken('PB Storage factory token', {
+    providedIn: 'any',
+    factory: () => sessionStorage
+});
+/**
+ * The default storage to cache the templates list. It can be either `localStorage` or `sessionStorage`.
+ */
+export const PB_TEMPLATES_TEMPORARY_STORAGE = new InjectionToken('PB Token that stores temporary templates cache', {
+    providedIn: 'any',
+    factory: () => sessionStorage
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokens.js","sourceRoot":"","sources":["../../../../../projects/pb-email-builder/src/lib/tokens/tokens.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { InjectionToken } from '@angular/core';\n\nimport { IForRootConf, IStructure } from '../interfaces/interfaces';\nimport { Structure } from '../classes/Structure';\nimport { ButtonBlock, DividerBlock, ImageBlock, SocialBlock, SpacerBlock, TBlocks, TextBlock } from '../classes/Elements';\n\n/**\n * Some top documentation\n */\n\n/**\n * The default social networks list provided by builder. This list is injected by {@link PB_SOCIAL_NETWORKS}.\n */\nexport const PB_DEFAULT_SOCIAL_NETWORKS: string[] = [\n  'github',\n  'instagram',\n  'web',\n  'snapchat',\n  'youtube',\n  'vimeo',\n  'medium',\n  'soundcloud',\n  'dribbble',\n  'facebook',\n  'twitter',\n  'pinterest',\n  'linkedin',\n  'tumblr',\n  'xing',\n  'tiktok'\n];\n/**\n * The token that injects [default social networks list]{@link PB_DEFAULT_SOCIAL_NETWORKS}.\n * Use it to add or remove social networks within list.\n *\n * @example\n * {provide: PB_SOCIAL_NETWORKS, useValue: PB_DEFAULT_SOCIAL_NETWORKS.filter(network => !['github', 'instagram'].includes(network)}\n */\nexport const PB_SOCIAL_NETWORKS = new InjectionToken<string[]>('PB Social Networks', {\n  providedIn: 'any',\n  factory: () => PB_DEFAULT_SOCIAL_NETWORKS\n});\n\n/**\n * The default [Google Fonts]{@link https://fonts.google.com} list provided by builder.\n * This list is injected by {@link PB_GOOGLE_FONTS} token.\n */\nexport const PB_DEFAULT_GOOGLE_FONTS: string[] = [\n  'Open+Sans:300,400,500,700',\n  'Droid+Sans:300,400,500,700',\n  'Lato:300,400,500,700',\n  'Roboto:300,400,700,900',\n  'Ubuntu:300,400,500,700',\n  'Fira+Sans:300,400,500,700',\n  'Mansalva:400'\n];\n/**\n * The token that injects [default google fonts]{@link PB_DEFAULT_GOOGLE_FONTS} list.\n */\nexport const PB_GOOGLE_FONTS = new InjectionToken<string[]>('PB Google Fonts', {\n  providedIn: 'any',\n  factory: () => PB_DEFAULT_GOOGLE_FONTS\n});\n\n/**\n * The default Fallback Fonts list provided by builder. This list is injected by {@link PB_FALLBACK_FONTS} token.\n *\n * A fallback font is a font that takes effect in case a [Google Font]{@link PB_DEFAULT_GOOGLE_FONTS} can't be loaded by some email\n * providers.\n */\nexport const PB_DEFAULT_FALLBACK_FONTS: string[] = [\n  'Palatino Linotype, Book Antiqua, Palatino, serif',\n  'Times New Roman, Times, serif',\n  'Arial, Helvetica, sans-serif',\n  'Arial Black, Gadget, sans-serif',\n  'Comic Sans MS, cursive, sans-serif',\n  'Impact, Charcoal, sans-serif',\n  'Lucida Sans Unicode, Lucida Grande, sans-serif',\n  'Tahoma, Geneva, sans-serif',\n  'Trebuchet MS, Helvetica, sans-serif',\n  'Verdana, Geneva, sans-serif',\n  'Courier New, Courier, monospace',\n  'Lucida Console, Monaco, monospace'\n];\n/**\n * The token that injects {@link PB_DEFAULT_FALLBACK_FONTS} list.\n */\nexport const PB_FALLBACK_FONTS = new InjectionToken<string[]>('PB Fallback Fonts', {\n  providedIn: 'any',\n  factory: () => PB_DEFAULT_FALLBACK_FONTS\n});\n\n/**\n * The default [Structures]{@link IStructure} list. This list is injected by {@link PB_STRUCTURES} token.\n */\nexport const PB_DEFAULT_STRUCTURES: IStructure[] = [\n  new Structure('cols_1'),\n  new Structure('cols_2'),\n  new Structure('cols_3'),\n  new Structure('cols_4'),\n  new Structure('cols_12'),\n  new Structure('cols_21')\n];\n/**\n * The token that injects {@link PB_DEFAULT_STRUCTURES} list.\n */\nexport const PB_STRUCTURES = new InjectionToken<typeof PB_DEFAULT_STRUCTURES>('PB Structures', {\n  providedIn: 'any',\n  factory: () => PB_DEFAULT_STRUCTURES\n});\n\n/**\n * The default [Blocks]{@link TBlocks} list. This list is injected by {@link PB_BLOCKS} token.\n */\nexport const PB_DEFAULT_BLOCKS: TBlocks[] = [\n  new TextBlock(),\n  new ImageBlock(),\n  new ButtonBlock(),\n  new DividerBlock(),\n  new SpacerBlock(),\n  new SocialBlock()\n];\n/**\n * The token that injects {@link PB_BLOCKS} list.\n */\nexport const PB_BLOCKS = new InjectionToken<typeof PB_DEFAULT_BLOCKS>('PB Blocks', {\n  providedIn: 'any',\n  factory: () => PB_DEFAULT_BLOCKS\n});\n\n/**\n * Default builder configuration, injected by {@link PB_CONFIG} token. See {@link IForRootConf} for more info.\n */\nexport const PB_DEFAULT_CONFIG: IForRootConf = Object.freeze({\n  xApiKey: 't7HdQfZjGp6R96fOV4P8v18ggf6LLTQZ1puUI2tz',\n  // apiPath: 'https://ngb-api.wlocalhost.org/v1',\n  useSaveButton: true,\n  usePreviewButton: true,\n  useDownloadButton: true,\n  templateListIfEmpty: true,\n  uploadImageName: 'image'\n});\n/**\n * The token that injects [default builder configurations]{@link PB_DEFAULT_CONFIG}.\n */\nexport const PB_CONFIG = new InjectionToken<Partial<IForRootConf>>('PB Builder Configuration', {\n  providedIn: 'root',\n  factory: () => PB_DEFAULT_CONFIG\n});\n\n/**\n * The default Storage used by builder. It can be either `localStorage` or `sessionStorage`.\n */\nexport const PB_STORAGE_FACTORY = new InjectionToken<Storage>('PB Storage factory token', {\n  providedIn: 'any',\n  factory: () => sessionStorage\n});\n\n/**\n * The default storage to cache the templates list. It can be either `localStorage` or `sessionStorage`.\n */\nexport const PB_TEMPLATES_TEMPORARY_STORAGE = new InjectionToken<Storage>('PB Token that stores temporary templates cache', {\n  providedIn: 'any',\n  factory: () => sessionStorage\n});\n"]}

package/esm2015/lib/utils.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { defer, of } from 'rxjs';
+// import { getDiff } from 'recursive-diff';
+/**
+ * An alternative lodash cloneDeep function. Use it on your own risk.
+ * @param obj Object to be cloned.
+ */
+export function cloneDeep(obj = {}) {
+    return JSON.parse(JSON.stringify(obj));
+}
+/**
+ * An alternative lodash isEqual function. Use it on your own risk.
+ * @param x Object to be compared
+ * @param y the second Object to be compared
+ */
+export function isEqual(x, y) {
+    // return !getDiff(x, y).length;
+    return JSON.stringify(x) === JSON.stringify(y);
+}
+/**
+ * An alternative lodash defaultsDeep function. Use it on your own risk.
+ * @param to The object with default properties
+ * @param sources An array of objects with default properties
+ */
+export function defaultsDeep(to = {}, ...sources) {
+    for (const source of sources) {
+        for (const key in source) {
+            if (to.hasOwnProperty(key)) {
+                continue;
+            }
+            if (!Array.isArray(source[key]) && typeof source[key] === 'object') {
+                to[key] = defaultsDeep(to[key], source[key]);
+            }
+            else {
+                to[key] = source[key];
+            }
+        }
+    }
+    return to;
+}
+/**
+ * Create CSS border styles based on {@link IBorder} object.
+ * @param border Border object.
+ * @param rule Most likely you won't need it, but for some cases, it can be changed. Default is: `border`.
+ *
+ * @return CSS Border styles.
+ */
+export function createBorder(border, rule = 'border') {
+    const { color = '#000000', style = 'solid', width = 4, radius = 0 } = border;
+    return {
+        [rule]: `${width}px ${style} ${color}`,
+        borderRadius: `${radius}px`
+    };
+}
+/**
+ * Create CSS padding styles based on {@link IPadding} object.
+ * @param padding Padding object.
+ * @param rule Most likely you won't need it, but for some cases, it can be changed. Default is: `padding`.
+ */
+export function createPadding(padding, rule = 'padding') {
+    const { top = 10, right = 25, bottom = 10, left = 25 } = padding;
+    return {
+        [rule]: `${top}px ${right}px ${bottom}px ${left}px`
+    };
+}
+/**
+ * Create CSS margin styles based on {@link IMargin} object.
+ * @param margin Margin object.
+ */
+export function createMargin(margin) {
+    const { top = 0, bottom = 0 } = margin;
+    return {
+        margin: `${top}px 0 ${bottom}px`
+    };
+}
+/**
+ * Create CSS font styles based on {@link IFont} object.
+ * @param font Font object.
+ */
+export function createFont(font) {
+    const { family = '', size = 13, style = 'normal', weight = 'normal' } = font;
+    return {
+        fontFamily: family,
+        fontSize: `${size}px`,
+        fontStyle: style,
+        fontWeight: weight
+    };
+}
+/**
+ * Create CSS line-height styles based on {@link ILineHeight} object.
+ * @param lineHeight Line-height object.
+ */
+export function createLineHeight(lineHeight) {
+    const { value = 22, unit = 'px' } = lineHeight;
+    return {
+        lineHeight: unit !== 'none' ? `${value}${unit}` : 'normal'
+    };
+}
+/**
+ * Create background styles based on {@link IBackground} object.
+ * @param background Background object.
+ */
+export function createBackground(background) {
+    const { url = '', color = 'white', repeat = 'no-repeat' } = background;
+    return `${color} ${url && `url(${url})`} ${repeat} top center`;
+}
+/**
+ * Create Width or Height styles based on {@link IWidthHeight} object.
+ * @param widthHeight Width or Height object.
+ */
+export function createWidthHeight(widthHeight) {
+    const { value = 100, unit = '%', auto = false } = widthHeight;
+    return (auto && 'auto') || (['%', 'px'].indexOf(unit) > -1 && `${value}${unit}`) || unit;
+}
+/**
+ * Convert bytes to KB-YB.
+ * @param bytes Bytes number.
+ * @param decimals How many decimals to be used. Default: 2.
+ */
+export function bytesToSize(bytes, decimals = 2) {
+    if (bytes === 0) {
+        return '0 Bytes';
+    }
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + sizes[i];
+}
+/**
+ * Get a Social Icon path.
+ * @param path Icon path. Ex: facebook.png
+ */
+export function getAssetByPath(path) {
+    return `https://www.mailjet.com/images/theme/v1/icons/ico-social/${path}`;
+}
+/**
+ * A simple and powerful function that allows to create an `Observable` only when it needs to be used.
+ * @param args Arguments to send to new Observable.
+ */
+export function deferOf(...args) {
+    return defer(() => of(...args));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../projects/pb-email-builder/src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { IBackground, IBorder, IFont, ILineHeight, IMargin, IPadding, IWidthHeight, TFontWeight } from './interfaces/interfaces';\nimport { defer, Observable, of } from 'rxjs';\n\n// import { getDiff } from 'recursive-diff';\n\n/**\n * An alternative lodash cloneDeep function. Use it on your own risk.\n * @param obj Object to be cloned.\n */\nexport function cloneDeep<T>(obj = {}): T {\n  return JSON.parse(JSON.stringify(obj));\n}\n\n/**\n * An alternative lodash isEqual function. Use it on your own risk.\n * @param x Object to be compared\n * @param y the second Object to be compared\n */\nexport function isEqual(x: object, y: object): boolean {\n  // return !getDiff(x, y).length;\n  return JSON.stringify(x) === JSON.stringify(y);\n}\n\n/**\n * An alternative lodash defaultsDeep function. Use it on your own risk.\n * @param to The object with default properties\n * @param sources An array of objects with default properties\n */\nexport function defaultsDeep<T>(to: T = {} as T, ...sources: T[]): T {\n  for (const source of sources) {\n    for (const key in source) {\n      if (to.hasOwnProperty(key)) {\n        continue;\n      }\n      if (!Array.isArray(source[key]) && typeof source[key] === 'object') {\n        to[key] = defaultsDeep(to[key], source[key]);\n      } else {\n        to[key] = source[key];\n      }\n    }\n  }\n  return (to as unknown) as T;\n}\n\n/**\n * Create CSS border styles based on {@link IBorder} object.\n * @param border Border object.\n * @param rule Most likely you won't need it, but for some cases, it can be changed. Default is: `border`.\n *\n * @return CSS Border styles.\n */\nexport function createBorder(border: IBorder, rule = 'border'): { [p: string]: string; borderRadius: string } {\n  const { color = '#000000', style = 'solid', width = 4, radius = 0 } = border;\n  return {\n    [rule]: `${width}px ${style} ${color}`,\n    borderRadius: `${radius}px`\n  };\n}\n\n/**\n * Create CSS padding styles based on {@link IPadding} object.\n * @param padding Padding object.\n * @param rule Most likely you won't need it, but for some cases, it can be changed. Default is: `padding`.\n */\nexport function createPadding(padding: IPadding, rule = 'padding'): { [p: string]: string } {\n  const { top = 10, right = 25, bottom = 10, left = 25 } = padding;\n  return {\n    [rule]: `${top}px ${right}px ${bottom}px ${left}px`\n  };\n}\n\n/**\n * Create CSS margin styles based on {@link IMargin} object.\n * @param margin Margin object.\n */\nexport function createMargin(margin: IMargin): { margin: string } {\n  const { top = 0, bottom = 0 } = margin;\n  return {\n    margin: `${top}px 0 ${bottom}px`\n  };\n}\n\n/**\n * Create CSS font styles based on {@link IFont} object.\n * @param font Font object.\n */\nexport function createFont(font: IFont): { fontFamily: string; fontSize: string; fontStyle: string; fontWeight: number | TFontWeight } {\n  const { family = '', size = 13, style = 'normal', weight = 'normal' } = font;\n  return {\n    fontFamily: family,\n    fontSize: `${size}px`,\n    fontStyle: style,\n    fontWeight: weight\n  };\n}\n\n/**\n * Create CSS line-height styles based on {@link ILineHeight} object.\n * @param lineHeight Line-height object.\n */\nexport function createLineHeight(lineHeight: ILineHeight): { lineHeight: string } {\n  const { value = 22, unit = 'px' } = lineHeight;\n  return {\n    lineHeight: unit !== 'none' ? `${value}${unit}` : 'normal'\n  };\n}\n\n/**\n * Create background styles based on {@link IBackground} object.\n * @param background Background object.\n */\nexport function createBackground(background: IBackground): string {\n  const { url = '', color = 'white', repeat = 'no-repeat' } = background;\n  return `${color} ${url && `url(${url})`} ${repeat} top center`;\n}\n\n/**\n * Create Width or Height styles based on {@link IWidthHeight} object.\n * @param widthHeight Width or Height object.\n */\nexport function createWidthHeight(widthHeight: IWidthHeight): string {\n  const { value = 100, unit = '%', auto = false } = widthHeight;\n  return (auto && 'auto') || (['%', 'px'].indexOf(unit) > -1 && `${value}${unit}`) || unit;\n}\n\n/**\n * Convert bytes to KB-YB.\n * @param bytes Bytes number.\n * @param decimals How many decimals to be used. Default: 2.\n */\nexport function bytesToSize(bytes: number, decimals = 2): string {\n  if (bytes === 0) {\n    return '0 Bytes';\n  }\n  const k = 1024;\n  const dm = decimals < 0 ? 0 : decimals;\n  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];\n  const i = Math.floor(Math.log(bytes) / Math.log(k));\n  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + sizes[i];\n}\n\n/**\n * Get a Social Icon path.\n * @param path Icon path. Ex: facebook.png\n */\nexport function getAssetByPath(path: string): string {\n  return `https://www.mailjet.com/images/theme/v1/icons/ico-social/${path}`;\n}\n\n/**\n * A simple and powerful function that allows to create an `Observable` only when it needs to be used.\n * @param args Arguments to send to new Observable.\n */\nexport function deferOf<T>(...args: T[]): Observable<T> {\n  return defer(() => of(...args));\n}\n"]}

package/esm2015/pobuca-email-builder.js

@@ -0,0 +1,43 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+export { BlockSettingsComponent as ɵbd } from './lib/components/block-settings/block-settings.component';
+export { BlockComponent as ɵf } from './lib/components/block/block.component';
+export { BuilderContainerComponent as ɵo } from './lib/components/builder-container/builder-container.component';
+export { ConfirmDialogComponent as ɵbb } from './lib/components/dialog.component';
+export { GeneralSettingsComponent as ɵbf } from './lib/components/general-settings/general-settings.component';
+export { ImportDialogComponent as ɵbj } from './lib/components/import-dialog/import-dialog.component';
+export { StructureSettingsComponent as ɵbe } from './lib/components/structure-settings/structure-settings.component';
+export { StructureComponent as ɵe } from './lib/components/structure/structure.component';
+export { TemplateListDialogComponent as ɵbi } from './lib/components/template-list-dialog/template-list-dialog.component';
+export { DynamicComponentDirective as ɵg } from './lib/directives/dynamic-component.directive';
+export { AbstractBlock as ɵi } from './lib/elements/abstract-block';
+export { ButtonComponent as ɵk } from './lib/elements/button/button.component';
+export { DividerComponent as ɵl } from './lib/elements/divider/divider.component';
+export { ImageComponent as ɵj } from './lib/elements/image/image.component';
+export { SocialComponent as ɵn } from './lib/elements/social/social.component';
+export { SpacerComponent as ɵm } from './lib/elements/spacer/spacer.component';
+export { TextElementComponent as ɵh } from './lib/elements/text-element/text-element.component';
+export { AlignComponent as ɵy } from './lib/groups/align';
+export { BackRepatComponent as ɵba } from './lib/groups/back-repeat';
+export { BorderComponent as ɵv } from './lib/groups/border';
+export { ColorComponent as ɵw } from './lib/groups/color';
+export { DirectionComponent as ɵz } from './lib/groups/direction';
+export { FontStylesComponent as ɵp } from './lib/groups/font-styles';
+export { GapsComponent as ɵs } from './lib/groups/gaps';
+export { LineHeightComponent as ɵt } from './lib/groups/line-height';
+export { LinkComponent as ɵx } from './lib/groups/link';
+export { MarginComponent as ɵr } from './lib/groups/margin';
+export { PaddingComponent as ɵq } from './lib/groups/padding';
+export { ImageUploadComponent as ɵbc } from './lib/groups/upload-image';
+export { WidthHeightComponent as ɵu } from './lib/groups/width-height';
+export { IpInterceptorInterceptor as ɵbk } from './lib/interceptors/pb-interceptor.interceptor';
+export { PbEmailObjectStoreService as ɵa } from './lib/services/internals/pb-email-object-store/pb-email-object-store.service';
+export { PbUserInterfaceService as ɵb } from './lib/services/internals/user-interfaces/user-interface.service';
+export { FreeUsersPbStorage as ɵd } from './lib/services/pb-storage';
+export { UploadBottomSheetDialogComponent as ɵbg } from './lib/services/user-image-uploader-service/upload-bottom-sheet-dialog/upload-bottom-sheet-dialog.component';
+export { UploadImageGalleryComponent as ɵbh } from './lib/services/user-image-uploader-service/upload-image-gallery/upload-image-gallery.component';
+export { FreeUsersRestApi as ɵc } from './lib/services/user-rest-api-service';
+export { LIBRARY_IS_PRO as ɵbl } from './lib/tokens/private-tokens';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public_api.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+/*
+ * Public API Surface of pb-email-builder
+ */
+export * from './lib/interfaces/interfaces';
+export * from './lib/tokens/tokens';
+// export * from './lib/providers';
+export * from './lib/utils';
+export * from './lib/classes/DefaultEmail';
+export * from './lib/classes/Elements';
+export * from './lib/classes/Structure';
+export * from './lib/pb-email-builder.service';
+export * from './lib/services/user-middleware-service/pb-middlewares.service';
+export * from './lib/services/user-rest-api-service/user-rest-api.service';
+export * from './lib/services/pb-storage/pb-storage.service';
+export { FreeUsersImageUploader } from './lib/services/user-image-uploader-service';
+export * from './lib/services/user-image-uploader-service/user-image-uploader.service';
+export * from './lib/pb-email-builder.module';
+export * from './lib/pb-email-builder.component';
+export * from './lib/components/preview.component';
+// export * from './lib/components/template-list-dialog/template-list-dialog.component';
+export * from './lib/pipes/slugify.pipe';
+//# sourceMappingURL=data:application/json;base64,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