@servicetitan/dte-unlayer 0.125.0 → 0.127.0

package/src/shared/fonts.ts

@@ -67,7 +67,7 @@ export const unlayerSupportedFonts = [
     {
         label: 'Sofia Pro',
         value: 'Sofia Pro',
-        url: 'https://fonts.cdnfonts.com/css/sofia-pro',
+        url: 'https://fonts.googleapis.com/css2?family=Sofia+Sans:ital,wght@0,1..1000;1,1..1000&display=swap',
     },
     {
         label: 'Nunito',

package/src/store.ts

@@ -1,6 +1,7 @@
 import { loadScript } from './loadScript';
 import { defaultImageValidation } from './shared/configs';
 import { UnlayerEditorTwin, UnlayerEventConfig, UnlayerEventRegister } from './shared/const';
+import { unlayerSupportedFonts } from './shared/fonts';
 import { FormFieldInfo, FormInfo } from './shared/forms';
 import { unlayerToolsParseTwinKey } from './shared/tools';
 import { unlayerToolsIterate } from './tools';
@@ -14,6 +15,80 @@ import { CreateUnlayerEditorProps, UnlayerDesignFormat, UnlayerRef } from './unl
 
 const defaultScriptUrl = 'https://editor.unlayer.com/embed.js?2';
 
+const normalizeFontToken = (font: string) =>
+    font
+        .replace(/["']/g, '')
+        .split(',')[0]
+        .trim()
+        .toLowerCase();
+
+const getDesignFontTokens = (value: any, out: Set<string>) => {
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            getDesignFontTokens(item, out);
+        }
+
+        return;
+    }
+
+    for (const [key, fieldValue] of Object.entries(value)) {
+        if (key === 'fontFamily') {
+            if (typeof fieldValue === 'string') {
+                out.add(normalizeFontToken(fieldValue));
+            } else if (fieldValue && typeof fieldValue === 'object') {
+                const fontFamilyValue = fieldValue as { label?: string; value?: string };
+
+                if (typeof fontFamilyValue.label === 'string') {
+                    out.add(normalizeFontToken(fontFamilyValue.label));
+                }
+
+                if (typeof fontFamilyValue.value === 'string') {
+                    out.add(normalizeFontToken(fontFamilyValue.value));
+                }
+            }
+        }
+
+        if (fieldValue && typeof fieldValue === 'object') {
+            getDesignFontTokens(fieldValue, out);
+        }
+    }
+};
+
+const ensureChunksFonts = (data: any) => {
+    if (!data || typeof data !== 'object') {
+        return data;
+    }
+
+    data.chunks ??= {};
+
+    const existingFonts: any[] = Array.isArray(data.chunks.fonts) ? data.chunks.fonts : [];
+    const existingLabels = new Set(existingFonts.map((f: any) => f.label));
+
+    const usedFontTokens = new Set<string>();
+    getDesignFontTokens(data.design, usedFontTokens);
+
+    const html = typeof data.html === 'string' ? data.html.toLowerCase() : '';
+
+    for (const font of unlayerSupportedFonts) {
+        const labelToken = normalizeFontToken(font.label);
+        const valueToken = normalizeFontToken(font.value);
+        const isUsedInDesign = usedFontTokens.has(labelToken) || usedFontTokens.has(valueToken);
+        const isUsedInHtml = !!html && (html.includes(labelToken) || html.includes(valueToken));
+
+        if ((isUsedInDesign || isUsedInHtml) && !existingLabels.has(font.label)) {
+            existingFonts.push(font);
+            existingLabels.add(font.label);
+        }
+    }
+
+    data.chunks.fonts = existingFonts;
+    return data;
+};
+
 export interface UnlayerDesignChangeInfo {
     isToolsListChanged: boolean;
 }
@@ -65,7 +140,7 @@ export class UnlayerStore {
             },
             exportHtml: cb => {
                 this.editor?.exportHtml(data => {
-                    cb(data);
+                    cb(ensureChunksFonts(data));
                 });
             },
             sendFormList: forms => {