@pobuca/email-builder 1.0.0

package/esm2015/lib/groups/align.js

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { PbEmailObjectStoreService } from '../services/internals/pb-email-object-store/pb-email-object-store.service';
+export class AlignComponent {
+    constructor(emailObject) {
+        this.emailObject = emailObject;
+        this.mode = 'horizontal';
+        this.labels = new Map([
+            ['left', $localize `:@@horizontal_align_left:Left`],
+            ['center', $localize `:@@horizontal_align_center:Center`],
+            ['right', $localize `:@@horizontal_align_right:Right`],
+            ['top', $localize `:@@vertical_align_top:Top`],
+            ['middle', $localize `:@@vertical_align_middle:Middle`],
+            ['bottom', $localize `:@@vertical_align_bottom:Bottom`]
+        ]);
+    }
+    get currentModel() {
+        return this.model.align || this.model.verticalAlign;
+    }
+    set currentModel(value) {
+        if (this.model.align) {
+            this.model.align = value;
+        }
+        else {
+            this.model.verticalAlign = value;
+        }
+        this.emailObject.markForCheck();
+    }
+    getLabel(key) {
+        return this.labels.get(key);
+    }
+    getPositions() {
+        if (this.mode === 'vertical') {
+            return ['top', 'middle', 'bottom'];
+        }
+        return ['left', 'center', 'right'];
+    }
+}
+AlignComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-align',
+                template: `
+    <mat-form-field appearance="outline">
+      <mat-label [ngSwitch]="mode">
+        <ng-container *ngSwitchCase="'vertical'" i18n="Align Settings|Vertical Align">Vertical Align</ng-container>
+        <ng-container *ngSwitchDefault i18n="Align Settings|Align">Align</ng-container>
+      </mat-label>
+      <mat-select [(ngModel)]="currentModel" disableRipple [disabled]="disabled">
+        <mat-option *ngFor="let position of getPositions()" [value]="position">
+          {{ getLabel(position) }}
+        </mat-option>
+      </mat-select>
+    </mat-form-field>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [`
+      :host {
+        display: block;
+        width: 100%;
+      }
+
+      mat-form-field {
+        width: 100%;
+      }
+    `]
+            },] }
+];
+AlignComponent.ctorParameters = () => [
+    { type: PbEmailObjectStoreService }
+];
+AlignComponent.propDecorators = {
+    model: [{ type: Input }],
+    mode: [{ type: Input }],
+    disabled: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/groups/back-repeat.js

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+export class BackRepatComponent {
+    constructor() {
+        this.disabled = false;
+        this.repeatLabels = new Map([
+            ['no-repeat', $localize `:@@no_repeat:No`],
+            ['repeat', $localize `:@@repeat:Repeat`],
+            ['repeat-x', $localize `:@@repeat_x:X`],
+            ['repeat-y', $localize `:@@repeat_y:Y`],
+            ['round', $localize `:@@repeat_round:Round`],
+            ['space', $localize `:@@repeat_space:Space`]
+        ]);
+    }
+    getRepeats() {
+        return ['no-repeat', 'repeat', 'repeat-x', 'repeat-y'];
+    }
+    getRepeatLabel(repeat) {
+        return this.repeatLabels.get(repeat);
+    }
+}
+BackRepatComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-back-repeat',
+                template: `
+    <mat-form-field appearance="outline">
+      <mat-label i18n="settings|Background Repeat">Repeat</mat-label>
+      <mat-select [(value)]="model.repeat" [disabled]="disabled" disableRipple>
+        <mat-option *ngFor="let repeat of getRepeats()" [value]="repeat">
+          {{ getRepeatLabel(repeat) }}
+        </mat-option>
+      </mat-select>
+    </mat-form-field>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [`
+      :host {
+        display: block;
+        width: 100%;
+      }
+
+      mat-form-field {
+        width: 100%;
+      }
+    `]
+            },] }
+];
+BackRepatComponent.propDecorators = {
+    model: [{ type: Input }],
+    disabled: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFjay1yZXBlYXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9wYi1lbWFpbC1idWlsZGVyL3NyYy9saWIvZ3JvdXBzL2JhY2stcmVwZWF0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBNkIxRSxNQUFNLE9BQU8sa0JBQWtCO0lBMUIvQjtRQTRCVyxhQUFRLEdBQUcsS0FBSyxDQUFDO1FBRWxCLGlCQUFZLEdBQUcsSUFBSSxHQUFHLENBQUM7WUFDN0IsQ0FBQyxXQUFXLEVBQUUsU0FBUyxDQUFBLGlCQUFpQixDQUFDO1lBQ3pDLENBQUMsUUFBUSxFQUFFLFNBQVMsQ0FBQSxrQkFBa0IsQ0FBQztZQUN2QyxDQUFDLFVBQVUsRUFBRSxTQUFTLENBQUEsZUFBZSxDQUFDO1lBQ3RDLENBQUMsVUFBVSxFQUFFLFNBQVMsQ0FBQSxlQUFlLENBQUM7WUFDdEMsQ0FBQyxPQUFPLEVBQUUsU0FBUyxDQUFBLHVCQUF1QixDQUFDO1lBQzNDLENBQUMsT0FBTyxFQUFFLFNBQVMsQ0FBQSx1QkFBdUIsQ0FBQztTQUM1QyxDQUFDLENBQUM7SUFTTCxDQUFDO0lBUEMsVUFBVTtRQUNSLE9BQU8sQ0FBQyxXQUFXLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUN6RCxDQUFDO0lBRUQsY0FBYyxDQUFDLE1BQXlCO1FBQ3RDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdkMsQ0FBQzs7O1lBN0NGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO2dCQUMxQixRQUFRLEVBQUU7Ozs7Ozs7OztHQVNUO2dCQWFELGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO3lCQVg3Qzs7Ozs7Ozs7O0tBU0M7YUFHSjs7O29CQUVFLEtBQUs7dUJBQ0wsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMjQgUG9idWNhLlxuICogQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqL1xuXG5pbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSUJhY2tncm91bmQsIFRCYWNrZ3JvdW5kUmVwZWF0IH0gZnJvbSAnLi4vaW50ZXJmYWNlcy9pbnRlcmZhY2VzJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAncGItYmFjay1yZXBlYXQnLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxtYXQtZm9ybS1maWVsZCBhcHBlYXJhbmNlPVwib3V0bGluZVwiPlxuICAgICAgPG1hdC1sYWJlbCBpMThuPVwic2V0dGluZ3N8QmFja2dyb3VuZCBSZXBlYXRcIj5SZXBlYXQ8L21hdC1sYWJlbD5cbiAgICAgIDxtYXQtc2VsZWN0IFsodmFsdWUpXT1cIm1vZGVsLnJlcGVhdFwiIFtkaXNhYmxlZF09XCJkaXNhYmxlZFwiIGRpc2FibGVSaXBwbGU+XG4gICAgICAgIDxtYXQtb3B0aW9uICpuZ0Zvcj1cImxldCByZXBlYXQgb2YgZ2V0UmVwZWF0cygpXCIgW3ZhbHVlXT1cInJlcGVhdFwiPlxuICAgICAgICAgIHt7IGdldFJlcGVhdExhYmVsKHJlcGVhdCkgfX1cbiAgICAgICAgPC9tYXQtb3B0aW9uPlxuICAgICAgPC9tYXQtc2VsZWN0PlxuICAgIDwvbWF0LWZvcm0tZmllbGQ+XG4gIGAsXG4gIHN0eWxlczogW1xuICAgIGBcbiAgICAgIDpob3N0IHtcbiAgICAgICAgZGlzcGxheTogYmxvY2s7XG4gICAgICAgIHdpZHRoOiAxMDAlO1xuICAgICAgfVxuXG4gICAgICBtYXQtZm9ybS1maWVsZCB7XG4gICAgICAgIHdpZHRoOiAxMDAlO1xuICAgICAgfVxuICAgIGBcbiAgXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgQmFja1JlcGF0Q29tcG9uZW50IHtcbiAgQElucHV0KCkgbW9kZWw6IElCYWNrZ3JvdW5kO1xuICBASW5wdXQoKSBkaXNhYmxlZCA9IGZhbHNlO1xuXG4gIHByaXZhdGUgcmVwZWF0TGFiZWxzID0gbmV3IE1hcChbXG4gICAgWyduby1yZXBlYXQnLCAkbG9jYWxpemVgOkBAbm9fcmVwZWF0Ok5vYF0sXG4gICAgWydyZXBlYXQnLCAkbG9jYWxpemVgOkBAcmVwZWF0OlJlcGVhdGBdLFxuICAgIFsncmVwZWF0LXgnLCAkbG9jYWxpemVgOkBAcmVwZWF0X3g6WGBdLFxuICAgIFsncmVwZWF0LXknLCAkbG9jYWxpemVgOkBAcmVwZWF0X3k6WWBdLFxuICAgIFsncm91bmQnLCAkbG9jYWxpemVgOkBAcmVwZWF0X3JvdW5kOlJvdW5kYF0sXG4gICAgWydzcGFjZScsICRsb2NhbGl6ZWA6QEByZXBlYXRfc3BhY2U6U3BhY2VgXVxuICBdKTtcblxuICBnZXRSZXBlYXRzKCk6IFRCYWNrZ3JvdW5kUmVwZWF0W10ge1xuICAgIHJldHVybiBbJ25vLXJlcGVhdCcsICdyZXBlYXQnLCAncmVwZWF0LXgnLCAncmVwZWF0LXknXTtcbiAgfVxuXG4gIGdldFJlcGVhdExhYmVsKHJlcGVhdDogVEJhY2tncm91bmRSZXBlYXQpOiBzdHJpbmcge1xuICAgIHJldHVybiB0aGlzLnJlcGVhdExhYmVscy5nZXQocmVwZWF0KTtcbiAgfVxufVxuIl19

package/esm2015/lib/groups/border.js

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { PbEmailObjectStoreService } from '../services/internals/pb-email-object-store/pb-email-object-store.service';
+export class BorderComponent {
+    constructor(emailObject) {
+        this.emailObject = emailObject;
+        this._styleLabels = new Map([
+            ['solid', $localize `:@@border_style_solid:Solid`],
+            ['dotted', $localize `:@@border_style_dotted:Dotted`],
+            ['dashed', $localize `:@@border_style_dashed:Dashed`],
+            ['double', $localize `:@@border_style_double:Double`],
+            ['groove', $localize `:@@border_style_groove:Groove`]
+        ]);
+    }
+    get styleLabels() {
+        return [...this._styleLabels.keys()];
+    }
+    getStyleLabel(style) {
+        // tslint:disable-next-line:no-non-null-assertion
+        return this._styleLabels.get(style);
+    }
+    markForCheck() {
+        this.emailObject.markForCheck();
+    }
+    isEven() {
+        return Object.keys(this.border).length % 2 === 0;
+    }
+    hasOwnProperty(property) {
+        return this.border.hasOwnProperty(property);
+    }
+}
+BorderComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-border',
+                template: `
+    <div class="group" [class.three]="isEven()">
+      <mat-form-field appearance="outline" *ngIf="hasOwnProperty('width')">
+        <mat-label i18n="Border Settings|Change Border Width">Width</mat-label>
+        <input
+          matInput
+          [(ngModel)]="border.width"
+          type="number"
+          min="0"
+          step="1"
+          (input)="markForCheck()"
+          i18n-placeholder
+          placeholder="Border Settings|Change Border Width"
+        />
+      </mat-form-field>
+      <mat-form-field appearance="outline" *ngIf="hasOwnProperty('radius')">
+        <mat-label i18n="Border Settings|Change Border Radius">Radius</mat-label>
+        <input
+          matInput
+          [(ngModel)]="border.radius"
+          type="number"
+          min="0"
+          step="1"
+          (input)="markForCheck()"
+          i18n-placeholder
+          placeholder="Border Settings|Change Border Radius"
+        />
+      </mat-form-field>
+      <mat-form-field appearance="outline" *ngIf="hasOwnProperty('style')" style="min-width: 90px">
+        <mat-label i18n="Border Settings|Change Border Style">Style</mat-label>
+        <mat-select
+          placeholder="Style"
+          [disabled]="!border.width"
+          [(value)]="border.style"
+          (selectionChange)="markForCheck()"
+          disableRipple
+        >
+          <mat-option *ngFor="let style of styleLabels" [value]="style">
+            {{ getStyleLabel(style) }}
+          </mat-option>
+        </mat-select>
+      </mat-form-field>
+    </div>
+    <pb-color [options]="border" [disabled]="!border.width" *ngIf="hasOwnProperty('color')" key="color"></pb-color>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [`
+      :host {
+        display: block;
+        width: 100%;
+      }
+
+      mat-form-field {
+        width: 100%;
+      }
+    `]
+            },] }
+];
+BorderComponent.ctorParameters = () => [
+    { type: PbEmailObjectStoreService }
+];
+BorderComponent.propDecorators = {
+    border: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/groups/color.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { ChangeDetectionStrategy, Component, HostListener, Input } from '@angular/core';
+import { PbEmailObjectStoreService } from '../services/internals/pb-email-object-store/pb-email-object-store.service';
+// import { PbEmailBuilderService } from '../pb-email-builder.service';
+// import { parseColor } from '../utils';
+export class ColorComponent {
+    constructor(emailObject) {
+        this.emailObject = emailObject;
+        this.disabled = false;
+        this.key = 'backgroundColor';
+        this.transparent = false;
+        this.showColorPicker = false;
+    }
+    get currentColorModel() {
+        return this.options[this.key];
+    }
+    set currentColorModel(hex) {
+        this.options[this.key] = hex;
+    }
+    get currentColor() {
+        return this.transparent ? this.oldValue : this.currentColorModel;
+    }
+    set currentColor(hex) {
+        this.currentColorModel = hex;
+    }
+    onHostMouseLeave() {
+        this.showColorPicker = false;
+    }
+    changeColor(event) {
+        this.currentColor = event.color.hex;
+        this.emailObject.markForCheck();
+    }
+    makeTransparentColor() {
+        this.showColorPicker = false;
+        if (this.transparent) {
+            this.oldValue = this.currentColorModel;
+            this.currentColor = 'transparent';
+        }
+        else {
+            this.currentColor = this.oldValue;
+        }
+        this.emailObject.markForCheck();
+    }
+    ngOnInit() {
+        if (this.currentColor === 'transparent') {
+            this.transparent = true;
+            this.oldValue = '#ffffff';
+        }
+        // this.changeContrastColor();
+    }
+}
+ColorComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-color',
+                template: `
+    <div class="group" *ngIf="showTransparent">
+      <mat-slide-toggle
+        [disabled]="disabled"
+        [(ngModel)]="transparent"
+        (change)="makeTransparentColor()"
+        i18n="Color settings|Make color transparent"
+      >
+        Transparent
+      </mat-slide-toggle>
+    </div>
+    <div class="group two">
+      <mat-form-field appearance="outline">
+        <mat-label i18n="Color settings|Change color">Color</mat-label>
+        <input matInput [disabled]="transparent || disabled" (focus)="showColorPicker = false" [(ngModel)]="currentColor" type="text" />
+      </mat-form-field>
+      <div class="choose-color" [class.transparent]="transparent || disabled">
+        <div class="current-color" (mouseover)="showColorPicker = !transparent" [style.backgroundColor]="currentColor"></div>
+        <color-chrome
+          [disableAlpha]="true"
+          *ngIf="showColorPicker"
+          (onChangeComplete)="changeColor($event)"
+          [color]="currentColor"
+        ></color-chrome>
+      </div>
+    </div>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [`
+      :host {
+        display: block;
+        position: relative;
+      }
+
+      mat-form-field {
+        width: 100%;
+      }
+
+      .choose-color {
+        display: block;
+        height: 100%;
+        width: 100%;
+      }
+
+      .current-color {
+        width: 100%;
+        height: 48px;
+        border-radius: 5px;
+        margin: 0.25em 0;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        border: 1px solid rgba(0, 0, 0, 0.12);
+        transition: background-color 500ms cubic-bezier(0.445, 0.05, 0.55, 0.95);
+      }
+
+      .choose-color.transparent .current-color {
+        opacity: 0.5;
+        pointer-events: none;
+      }
+
+      color-chrome {
+        position: absolute;
+        top: calc(100% - 1em);
+        right: 0;
+        z-index: 9;
+      }
+    `]
+            },] }
+];
+ColorComponent.ctorParameters = () => [
+    { type: PbEmailObjectStoreService }
+];
+ColorComponent.propDecorators = {
+    options: [{ type: Input }],
+    showTransparent: [{ type: Input }],
+    disabled: [{ type: Input }],
+    key: [{ type: Input }],
+    onHostMouseLeave: [{ type: HostListener, args: ['mouseleave',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/groups/direction.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { PbEmailObjectStoreService } from '../services/internals/pb-email-object-store/pb-email-object-store.service';
+export class DirectionComponent {
+    constructor(emailObject) {
+        this.emailObject = emailObject;
+        this.dirLabels = new Map([
+            ['ltr', $localize `:@@direction_ltr:Left to right`],
+            ['rtl', $localize `:@@direction_rtl:Right to left`]
+        ]);
+    }
+    markForCheck() {
+        this.emailObject.markForCheck();
+    }
+    getDirections() {
+        return ['ltr', 'rtl'];
+    }
+    getDirectionLabel(dir) {
+        return this.dirLabels.get(dir);
+    }
+}
+DirectionComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-direction',
+                template: `
+    <mat-form-field appearance="outline">
+      <mat-label i18n="settings|Direction">Direction</mat-label>
+      <mat-select
+        i18n-placeholder="settings|Direction"
+        placeholder="Direction"
+        [(value)]="model.direction"
+        (selectionChange)="markForCheck()"
+        disableRipple
+      >
+        <mat-option *ngFor="let dir of getDirections()" [value]="dir">
+          {{ getDirectionLabel(dir) }}
+        </mat-option>
+      </mat-select>
+    </mat-form-field>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [`
+      :host {
+        display: block;
+        width: 100%;
+      }
+
+      mat-form-field {
+        width: 100%;
+      }
+    `]
+            },] }
+];
+DirectionComponent.ctorParameters = () => [
+    { type: PbEmailObjectStoreService }
+];
+DirectionComponent.propDecorators = {
+    model: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/groups/font-styles.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2024 Pobuca.
+ * All rights reserved.
+ */
+import { ChangeDetectionStrategy, Component, Inject, Input } from '@angular/core';
+import { PB_FALLBACK_FONTS, PB_GOOGLE_FONTS } from '../tokens/tokens';
+import { PbEmailObjectStoreService } from '../services/internals/pb-email-object-store/pb-email-object-store.service';
+export class FontStylesComponent {
+    constructor(pbEmailObject, googleFonts, fallbackFonts) {
+        this.pbEmailObject = pbEmailObject;
+        this.fallbackFonts = fallbackFonts;
+        this.fontsMap = new Map();
+        this.stylesMap = new Map([
+            ['normal', $localize `:@@font_style_normal:Normal`],
+            ['italic', $localize `:@@font_style_italic:Italic`],
+            ['oblique', $localize `:@@font_style_oblique:Oblique`]
+        ]);
+        googleFonts.forEach(font => {
+            const [family, ...weights] = font.match(/[^\d:,]{2,}|\d{3}/g);
+            this.fontsMap.set(family.replace('+', ' '), [...new Set(weights.map(Number))]);
+        });
+    }
+    get fontWeightList() {
+        return this.isGoogleFont() ? this.fontsMap.get(this.font.family) : [100, 400, 500, 700, 900];
+    }
+    get fontFamilyList() {
+        return [...this.fontsMap.keys(), ...this.fallbackFonts];
+    }
+    get styles() {
+        return [...this.stylesMap.keys()];
+    }
+    markForCheck() {
+        this.pbEmailObject.markForCheck();
+    }
+    isGoogleFont() {
+        return this.fontsMap.has(this.font.family);
+    }
+    getStyleLabel(style) {
+        // tslint:disable-next-line:no-non-null-assertion
+        return this.stylesMap.get(style);
+    }
+    hasProperty(property) {
+        return this.font.hasOwnProperty(property);
+    }
+}
+FontStylesComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'pb-font-styles',
+                template: `
+    <div class="group two">
+      <mat-form-field appearance="outline" *ngIf="hasProperty('family')">
+        <mat-label i18n="settings|Font Family">Family</mat-label>
+        <mat-select [(value)]="font.family" disableRipple (selectionChange)="markForCheck()">
+          <mat-option *ngFor="let name of fontFamilyList" [ngStyle]="{ fontFamily: name }" [value]="name">
+            {{ name }}
+          </mat-option>
+        </mat-select>
+        <mat-hint *ngIf="isGoogleFont()" i18n="settings|Partial support">Partial support.</mat-hint>
+        <mat-hint *ngIf="!isGoogleFont()" i18n="settings|Full support">Full support.</mat-hint>
+      </mat-form-field>
+      <mat-form-field appearance="outline" *ngIf="hasProperty('fallback')">
+        <mat-label i18n="settings|Font Fallback">Fallback</mat-label>
+        <mat-select [(value)]="font.fallback" [disabled]="!isGoogleFont()" disableRipple (selectionChange)="markForCheck()">
+          <mat-option *ngFor="let name of fallbackFonts" [ngStyle]="{ fontFamily: name }" [value]="name">
+            {{ name }}
+          </mat-option>
+        </mat-select>
+        <mat-hint i18n="settings|Full support">Full support.</mat-hint>
+      </mat-form-field>
+    </div>
+
+    <div class="group three">
+      <mat-form-field appearance="outline" *ngIf="hasProperty('size')">
+        <mat-label i18n="settings|Font Size">Size</mat-label>
+        <input matInput type="number" max="30" min="10" step="1" (input)="markForCheck()" [(ngModel)]="font.size" />
+      </mat-form-field>
+      <mat-form-field appearance="outline" *ngIf="hasProperty('weight')">
+        <mat-label i18n="settings|Font Weight">Weight</mat-label>
+        <mat-select placeholder="Weight" [(value)]="font.weight" disableRipple (selectionChange)="markForCheck()">
+          <mat-option *ngFor="let weight of fontWeightList" [value]="weight">
+            {{ weight }}
+          </mat-option>
+        </mat-select>
+      </mat-form-field>
+      <mat-form-field appearance="outline" style="min-width: 90px;">
+        <mat-label i18n="settings|Font Style">Style</mat-label>
+        <mat-select placeholder="Style" [(value)]="font.style" disableRipple (selectionChange)="markForCheck()">
+          <mat-option *ngFor="let style of styles" [value]="style" i18n>
+            {{ getStyleLabel(style) }}
+          </mat-option>
+        </mat-select>
+      </mat-form-field>
+    </div>
+  `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [`
+      :host {
+        display: block;
+        width: 100%;
+      }
+    `]
+            },] }
+];
+FontStylesComponent.ctorParameters = () => [
+    { type: PbEmailObjectStoreService },
+    { type: Array, decorators: [{ type: Inject, args: [PB_GOOGLE_FONTS,] }] },
+    { type: Array, decorators: [{ type: Inject, args: [PB_FALLBACK_FONTS,] }] }
+];
+FontStylesComponent.propDecorators = {
+    font: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"font-styles.js","sourceRoot":"","sources":["../../../../../projects/pb-email-builder/src/lib/groups/font-styles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAElF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,2EAA2E,CAAC;AA4DtH,MAAM,OAAO,mBAAmB;IAS9B,YACU,aAAwC,EACvB,WAAqB,EACZ,aAAuB;QAFjD,kBAAa,GAAb,aAAa,CAA2B;QAEd,kBAAa,GAAb,aAAa,CAAU;QAVnD,aAAQ,GAAG,IAAI,GAAG,EAAoB,CAAC;QACvC,cAAS,GAAG,IAAI,GAAG,CAAyB;YAClD,CAAC,QAAQ,EAAE,SAAS,CAAA,6BAA6B,CAAC;YAClD,CAAC,QAAQ,EAAE,SAAS,CAAA,6BAA6B,CAAC;YAClD,CAAC,SAAS,EAAE,SAAS,CAAA,+BAA+B,CAAC;SACtD,CAAC,CAAC;QAOD,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACzB,MAAM,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;YAC9D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACjF,CAAC,CAAC,CAAC;IACL,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAC/F,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,MAAM;QACR,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;IACpC,CAAC;IAED,YAAY;QACV,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;IACpC,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,aAAa,CAAC,KAAqB;QACjC,iDAAiD;QACjD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC;IACpC,CAAC;IAED,WAAW,CAAC,QAAgB;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;;;YAzGF,SAAS,SAAC;gBACT,QAAQ,EAAE,gBAAgB;gBAC1B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CT;gBASD,eAAe,EAAE,uBAAuB,CAAC,MAAM;yBAP7C;;;;;KAKC;aAGJ;;;YA3DQ,yBAAyB;wCAuE7B,MAAM,SAAC,eAAe;wCACtB,MAAM,SAAC,iBAAiB;;;mBAX1B,KAAK","sourcesContent":["/*\n * Copyright (c) 2024 Pobuca.\n * All rights reserved.\n */\n\nimport { ChangeDetectionStrategy, Component, Inject, Input } from '@angular/core';\nimport { IFont } from '../interfaces/interfaces';\nimport { PB_FALLBACK_FONTS, PB_GOOGLE_FONTS } from '../tokens/tokens';\nimport { PbEmailObjectStoreService } from '../services/internals/pb-email-object-store/pb-email-object-store.service';\n\n@Component({\n  selector: 'pb-font-styles',\n  template: `\n    <div class=\"group two\">\n      <mat-form-field appearance=\"outline\" *ngIf=\"hasProperty('family')\">\n        <mat-label i18n=\"settings|Font Family\">Family</mat-label>\n        <mat-select [(value)]=\"font.family\" disableRipple (selectionChange)=\"markForCheck()\">\n          <mat-option *ngFor=\"let name of fontFamilyList\" [ngStyle]=\"{ fontFamily: name }\" [value]=\"name\">\n            {{ name }}\n          </mat-option>\n        </mat-select>\n        <mat-hint *ngIf=\"isGoogleFont()\" i18n=\"settings|Partial support\">Partial support.</mat-hint>\n        <mat-hint *ngIf=\"!isGoogleFont()\" i18n=\"settings|Full support\">Full support.</mat-hint>\n      </mat-form-field>\n      <mat-form-field appearance=\"outline\" *ngIf=\"hasProperty('fallback')\">\n        <mat-label i18n=\"settings|Font Fallback\">Fallback</mat-label>\n        <mat-select [(value)]=\"font.fallback\" [disabled]=\"!isGoogleFont()\" disableRipple (selectionChange)=\"markForCheck()\">\n          <mat-option *ngFor=\"let name of fallbackFonts\" [ngStyle]=\"{ fontFamily: name }\" [value]=\"name\">\n            {{ name }}\n          </mat-option>\n        </mat-select>\n        <mat-hint i18n=\"settings|Full support\">Full support.</mat-hint>\n      </mat-form-field>\n    </div>\n\n    <div class=\"group three\">\n      <mat-form-field appearance=\"outline\" *ngIf=\"hasProperty('size')\">\n        <mat-label i18n=\"settings|Font Size\">Size</mat-label>\n        <input matInput type=\"number\" max=\"30\" min=\"10\" step=\"1\" (input)=\"markForCheck()\" [(ngModel)]=\"font.size\" />\n      </mat-form-field>\n      <mat-form-field appearance=\"outline\" *ngIf=\"hasProperty('weight')\">\n        <mat-label i18n=\"settings|Font Weight\">Weight</mat-label>\n        <mat-select placeholder=\"Weight\" [(value)]=\"font.weight\" disableRipple (selectionChange)=\"markForCheck()\">\n          <mat-option *ngFor=\"let weight of fontWeightList\" [value]=\"weight\">\n            {{ weight }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n      <mat-form-field appearance=\"outline\" style=\"min-width: 90px;\">\n        <mat-label i18n=\"settings|Font Style\">Style</mat-label>\n        <mat-select placeholder=\"Style\" [(value)]=\"font.style\" disableRipple (selectionChange)=\"markForCheck()\">\n          <mat-option *ngFor=\"let style of styles\" [value]=\"style\" i18n>\n            {{ getStyleLabel(style) }}\n          </mat-option>\n        </mat-select>\n      </mat-form-field>\n    </div>\n  `,\n  styles: [\n    `\n      :host {\n        display: block;\n        width: 100%;\n      }\n    `\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FontStylesComponent {\n  @Input() font: IFont;\n  private fontsMap = new Map<string, number[]>();\n  private stylesMap = new Map<IFont['style'], string>([\n    ['normal', $localize`:@@font_style_normal:Normal`],\n    ['italic', $localize`:@@font_style_italic:Italic`],\n    ['oblique', $localize`:@@font_style_oblique:Oblique`]\n  ]);\n\n  constructor(\n    private pbEmailObject: PbEmailObjectStoreService,\n    @Inject(PB_GOOGLE_FONTS) googleFonts: string[],\n    @Inject(PB_FALLBACK_FONTS) public fallbackFonts: string[]\n  ) {\n    googleFonts.forEach(font => {\n      const [family, ...weights] = font.match(/[^\\d:,]{2,}|\\d{3}/g);\n      this.fontsMap.set(family.replace('+', ' '), [...new Set(weights.map(Number))]);\n    });\n  }\n\n  get fontWeightList() {\n    return this.isGoogleFont() ? this.fontsMap.get(this.font.family) : [100, 400, 500, 700, 900];\n  }\n\n  get fontFamilyList() {\n    return [...this.fontsMap.keys(), ...this.fallbackFonts];\n  }\n\n  get styles(): IFont['style'][] {\n    return [...this.stylesMap.keys()];\n  }\n\n  markForCheck() {\n    this.pbEmailObject.markForCheck();\n  }\n\n  isGoogleFont() {\n    return this.fontsMap.has(this.font.family);\n  }\n\n  getStyleLabel(style: IFont['style']): string {\n    // tslint:disable-next-line:no-non-null-assertion\n    return this.stylesMap.get(style)!;\n  }\n\n  hasProperty(property: string) {\n    return this.font.hasOwnProperty(property);\n  }\n}\n"]}