@chenyomi/leafer-htmltext-editor 1.0.0

package/dist/esm/utils.js

@@ -0,0 +1,284 @@
+import { TextEditor } from './TextEditor';
+function getEditorContext() {
+    const quill = TextEditor.quill;
+    return { quill };
+}
+export const updataHtmlText = async (e, base64font, fontObj) => {
+    const { scaleX, scaleY } = e.worldTransform;
+    const zoomScale = Math.max(Math.abs(scaleX), Math.abs(scaleY));
+    const dom = document.querySelector('#textInnerEditor');
+    if (dom && e.data.textData?.fontFamily) {
+        dom.style.fontFamily = e.data.textData.fontFamily;
+    }
+    if (dom && e.data.textData?.fontSize) {
+        dom.style.fontSize = `${e.data.textData.fontSize * zoomScale}px`;
+    }
+    if (dom && e.data.textData?.lineHeight) {
+        dom.style.lineHeight = e.data.textData.lineHeight;
+    }
+    if (dom && e.data.textData?.letterSpacing) {
+        dom.style.letterSpacing = `${e.data.textData.letterSpacing}px`;
+    }
+    if (dom && e.data.textData?.textShadow) {
+        dom.style.textShadow = e.data.textData.textShadow;
+    }
+    else if (dom) {
+        dom.style.textShadow = 'none';
+    }
+    if (dom && e.data.textData?.alignContent) {
+        const qlEditor = dom.querySelector('.ql-editor');
+        if (qlEditor) {
+            qlEditor.style.alignContent = e.data.textData.alignContent;
+        }
+    }
+    const { quill } = getEditorContext();
+    if (!quill)
+        return;
+    const html = quill.getSemanticHTML();
+    if (html === '<p></p>') {
+        if (e.text.includes('<style>@font-face')) {
+            e.text = e.text.split('</style>')[0] + '</style>';
+        }
+        else {
+            e.text = '';
+        }
+        return;
+    }
+    if (e.text.includes('<style>@font-face')) {
+        const style = e.text.split('</style>')[0];
+        if (fontObj && !style.includes(fontObj.code)) {
+            const addStyle = `@font-face {font-family: ${fontObj.code};src: url(${base64font}) format('woff2') } .ql-font-${fontObj?.code?.replace(/\s+/g, '')} {font-family: ${fontObj.name};}`;
+            e.text =
+                style +
+                    addStyle +
+                    '</style>' +
+                    addFontSizeToP(e, html, e.data.textData.fontSize, e.data.textData.lineHeight, e.data.textData.letterSpacing, e.data.textData.textShadow, e.data.textData?.alignContent);
+        }
+        else {
+            e.text =
+                style +
+                    '</style>' +
+                    addFontSizeToP(e, html, e.data.textData.fontSize, e.data.textData.lineHeight, e.data.textData.letterSpacing, e.data.textData.textShadow, e.data.textData?.alignContent);
+        }
+    }
+    else if (base64font && fontObj) {
+        const style = `<style>@font-face {font-family: ${e.data.textData.fontFamily.split(',')[0]};src: url(${base64font}) format('woff2') } .ql-font-${fontObj?.code?.replace(/\s+/g, '')} {font-family: ${fontObj.name};}</style>`;
+        e.text =
+            style +
+                addFontSizeToP(e, html, e.data.textData.fontSize, e.data.textData.lineHeight, e.data.textData.letterSpacing, e.data.textData.textShadow, e.data.textData?.alignContent);
+    }
+    else {
+        e.text = addFontSizeToP(e, html, e.data.textData.fontSize, e.data.textData.lineHeight, e.data.textData.letterSpacing, e.data.textData.textShadow, e.data.textData?.alignContent);
+    }
+};
+const addFontSizeToP = (e, html, fontSize = 16, lineHeight = '1.5', letterSpacing = '0', textShadow = 'none', alignContent = 'start') => {
+    const { quill } = getEditorContext();
+    if (!quill)
+        return html;
+    const { scaleX, scaleY } = e.worldTransform;
+    const zoomScale = Math.max(Math.abs(scaleX), Math.abs(scaleY));
+    const wrapper = document.createElement('div');
+    wrapper.innerHTML = html;
+    const wrapperStyle = {
+        fontSize: `${fontSize}px`,
+        lineHeight,
+        letterSpacing: `${letterSpacing}px`,
+        textShadow
+    };
+    wrapper.querySelectorAll('p,ol,ul').forEach((p) => {
+        Object.assign(p.style, wrapperStyle);
+    });
+    let str = wrapper.innerHTML;
+    if (/<p\b[^>]*><\/p>/.test(str)) {
+        str = str.replace(/<p\b([^>]*)><\/p>/g, '<p$1>&nbsp;</p>');
+    }
+    let height;
+    const div = document.querySelector('#textInnerEditor');
+    const actualHeight = Number((quill.scroll.domNode.scrollHeight / zoomScale).toFixed(0));
+    const actualWidth = Number((quill.scroll.domNode.scrollWidth / zoomScale).toFixed(0));
+    if (['center', 'end'].includes(e.data.textData.alignContent)) {
+        if (e.parent.height < actualHeight) {
+            e.data.textData.alignContent = 'start';
+            height = (actualHeight || e.__layout.boxBounds.height) + 'px';
+        }
+        else {
+            height = `${e.parent.height}px`;
+        }
+    }
+    else {
+        if (e.parent.height < actualHeight) {
+            height = (actualHeight || e.__layout.boxBounds.height) + 'px';
+        }
+        else {
+            height = `${e.parent.height}px`;
+        }
+    }
+    const style = `<style>sub,sup{font-size:63%;}.ql-ui{position:absolute}ol,ul{counter-reset:list-0;padding-left:1.5em;margin:0}ol>li,ul>li{counter-increment:list-0;list-style-type:none;position:relative;padding-left:0;margin:0}ol>li::before{content:counter(list-0,decimal) '. ';position:absolute;left:-1.5em;width:1.2em;text-align:right}ul>li::before{content:'\\u2022';position:absolute;left:-1.5em;width:1.2em;text-align:right}li[data-list]{counter-set:list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9}.ql-align-center{text-align:center}.ql-align-right{text-align:right}.ql-align-left{text-align:left}.ql-align-justify{text-align:justify}</style>`;
+    let divBox = '';
+    if (e.parent.children[0].tag.includes('Shape')) {
+        divBox =
+            style +
+                `<div style="width: ${e.parent.width}px;height: ${e.parent.height}px;overflow-wrap:break-word;word-break:break-all;align-content:center;">${str}</div>`;
+    }
+    else if (e.data.canChangeBox) {
+        divBox =
+            style +
+                `<div style="width: ${e.parent.width}px;height:${height};overflow-wrap:break-word;word-break:break-all;align-content:${alignContent};">${str}</div>`;
+    }
+    else {
+        if (e.data.textData.italic) {
+            divBox = style + str;
+        }
+        else {
+            divBox = style + `<div style="width: ${actualWidth - 10}px">${str}</div>`;
+        }
+    }
+    console.log(divBox, '最终的html内容');
+    return divBox;
+};
+export const setHTMLText = (key, value, base64font, editor, isInnerEditor) => {
+    const { quill } = getEditorContext();
+    if (!quill) {
+        console.error('Quill editor not initialized');
+        return;
+    }
+    const rangeStr = localStorage.getItem('selection-change');
+    const range = rangeStr ? JSON.parse(rangeStr) : null;
+    if (range && isInnerEditor) {
+        quill.setSelection(range.index, range.length);
+    }
+    if (!editor || !editor.dateEdit) {
+        console.warn('Editor context not available for dateEdit');
+        return;
+    }
+    editor.dateEdit(async (e) => {
+        if (key === 'font') {
+            const fontSimpleName = value.code.replace(/\s+/g, '');
+            if (isInnerEditor) {
+                if (range && range.length) {
+                    quill.formatText(range.index, range.length, key, fontSimpleName);
+                }
+                else {
+                    quill.formatText(0, quill.getLength() - 1, key, fontSimpleName);
+                }
+                updataHtmlText(e, base64font ?? null, value ?? null);
+            }
+            else {
+                editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+                quill.formatText(0, quill.getLength() - 1, key, fontSimpleName);
+                updataHtmlText(e, base64font ?? null, value ?? null);
+            }
+        }
+        else if (key === 'fontSize') {
+            e.data.textData[key] = value;
+            editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+            updataHtmlText(e, base64font ?? null);
+        }
+        else if (key === 'textCase') {
+            if (isInnerEditor && range) {
+                const text = quill.getText(range.index, range.length);
+                const formats = quill.getFormat(range.index, range.length);
+                quill.deleteText(range.index, range.length);
+                let convertedText;
+                if (text === text.toUpperCase() && /[A-Z]/.test(text)) {
+                    convertedText = text.toLowerCase();
+                }
+                else if (text === text.toLowerCase() && /[a-z]/.test(text)) {
+                    convertedText = text.toUpperCase();
+                }
+                else {
+                    convertedText = text.toUpperCase();
+                }
+                quill.insertText(range.index, convertedText, formats);
+                if (range && isInnerEditor) {
+                    quill.setSelection(range.index, range.length);
+                }
+            }
+        }
+        else if (key === 'script') {
+            let val = 'sub';
+            if (value === 'super')
+                val = 'sup';
+            if (isInnerEditor) {
+                if (range && range.length) {
+                    quill.formatText(range.index, range.length, key, quill.getFormat(range).script === value ? false : val);
+                }
+                else {
+                    quill.formatText(0, quill.getLength() - 1, key, quill.getFormat().script === value ? false : val);
+                }
+            }
+            else {
+                editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+                quill.formatText(0, quill.getLength() - 1, key, quill.getFormat().script === value ? false : val);
+                updataHtmlText(e);
+            }
+        }
+        else if (key === 'align') {
+            editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+            if (isInnerEditor) {
+                quill.format(key, value);
+            }
+            else {
+                quill.formatLine(0, quill.getLength(), key, value);
+            }
+            updataHtmlText(e);
+        }
+        else if (key === 'alignContent') {
+            editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+            e.data.textData[key] = value;
+            updataHtmlText(e);
+        }
+        else if (key === 'color') {
+            editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+            quill.formatText(0, quill.getLength() - 1, key, value);
+            if (e.tag === 'HTMLText') {
+                updataHtmlText(e);
+            }
+            else if (e.parent.findOne && e.parent.findOne('HTMLText')) {
+                updataHtmlText(e.parent.findOne('HTMLText'));
+            }
+        }
+        else if (key === 'textShadow') {
+            editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+            e.data.textData[key] = value;
+            updataHtmlText(e);
+        }
+        else if (key === 'list') {
+            editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+            if (isInnerEditor) {
+                const [line] = quill.getLine(range?.index || 0);
+                if (line.formats().list) {
+                    quill.format(key, false);
+                }
+                else {
+                    quill.format(key, value);
+                }
+            }
+            else {
+                const [line] = quill.getLine(range?.index || 0);
+                if (line.formats().list) {
+                    quill.formatLine(0, quill.getLength(), key, false);
+                }
+                else {
+                    quill.formatLine(0, quill.getLength(), key, value);
+                }
+            }
+            updataHtmlText(e);
+        }
+        else {
+            if (isInnerEditor) {
+                if (range && range.length) {
+                    quill.formatText(range.index, range.length, key, !quill.getFormat(range)[key]);
+                }
+                else {
+                    quill.formatText(0, quill.getLength() - 1, key, !quill.getFormat()[key]);
+                }
+            }
+            else {
+                editor.isMultiSelect && editor.isMultiSelect() && quill.clipboard.dangerouslyPasteHTML(e.text);
+                quill.formatText(0, quill.getLength() - 1, key, !quill.getFormat()[key]);
+                updataHtmlText(e);
+            }
+        }
+    }, 1);
+};

package/dist/fonts/font.d.ts

@@ -0,0 +1,17 @@
+export declare const defaultFonts: {
+    code: string;
+    name: string;
+    url: string;
+}[];
+export declare class FontManager {
+    private fontList;
+    private skipLoadFonts;
+    private loadFonts;
+    constructor();
+    initFonts(): Promise<any[]>;
+    getFontList(): any[];
+    getSkipLoadFonts(): any[];
+    getLoadFonts(): any[];
+}
+export declare const fontManager: FontManager;
+//# sourceMappingURL=font.d.ts.map

package/dist/fonts/font.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font.d.ts","sourceRoot":"","sources":["../../src/fonts/font.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;GA2BxB,CAAC;AAMF,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,aAAa,CAAkD;IACvE,OAAO,CAAC,SAAS,CAAuB;;IASlC,SAAS;IA0Bf,WAAW;IAIX,gBAAgB;IAIhB,YAAY;CAGb;AAGD,eAAO,MAAM,WAAW,aAAoB,CAAC"}

package/dist/fonts/font.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fontManager = exports.FontManager = exports.defaultFonts = void 0;
+exports.defaultFonts = [
+    { code: 'Roboto', name: `"Roboto", sans-serif`, url: '/fonts/Roboto.woff2' },
+    { code: 'Roboto Mono', name: `"Roboto Mono", monospace`, url: '/fonts/RobotoMono.woff2' },
+    { code: 'Inter', name: `"Inter", sans-serif`, url: '/fonts/Inter.woff2' },
+    { code: 'Open Sans', name: `"Open Sans", sans-serif`, url: '/fonts/OpenSans.woff2' },
+    { code: 'Montserrat', name: `"Montserrat", sans-serif`, url: '/fonts/Montserrat.woff2' },
+    { code: 'Roboto Condensed', name: `"Roboto Condensed", sans-serif`, url: '/fonts/RobotoCondensed.woff2' },
+    { code: 'Arimo', name: `"Arimo", sans-serif`, url: '/fonts/Arimo.woff2' },
+    { code: 'Noto Sans', name: `"Noto Sans", sans-serif`, url: '/fonts/NotoSans.woff2' },
+    { code: 'Noto Sans Symbols', name: `"Noto Sans Symbols", sans-serif`, url: '/fonts/NotoSansSymbols.woff2' },
+    { code: 'Merriweather', name: `"Merriweather", serif`, url: '/fonts/Merriweather.woff2' },
+    { code: 'Playfair Display', name: `"Playfair Display", serif`, url: '/fonts/PlayfairDisplay.woff2' },
+    { code: 'Noto Serif', name: `"Noto Serif", serif`, url: '/fonts/NotoSerif.woff2' },
+    { code: 'Lato', name: `"Lato", sans-serif`, url: '/fonts/Lato.woff2' },
+    { code: 'Spectral', name: `"Spectral", serif`, url: '/fonts/Spectral.woff2' },
+    { code: 'Dancing Script', name: `"Dancing Script", cursive`, url: '/fonts/DancingScript.woff2' },
+    { code: 'Noto Sans Simplified Chinese', name: `"Noto Sans SC", sans-serif`, url: '/fonts/NotoSansSimplifiedChinese.woff2' },
+    { code: 'Noto Serif Simplified Chinese', name: `"Noto Serif SC", serif`, url: '/fonts/NotoSerifSimplifiedChinese.woff2' },
+    { code: 'Noto Sans Traditional Chinese', name: `"Noto Sans TC", sans-serif`, url: '/fonts/NotoSansTraditionalChinese.woff2' },
+    { code: 'Noto Sans Hong Kong', name: `"Noto Sans HK", sans-serif`, url: '/fonts/NotoSansHongKong.woff2' },
+    { code: 'Noto Serif Traditional Chinese', name: `"Noto Serif TC", serif`, url: '/fonts/NotoSerifTraditionalChinese.woff2' },
+    { code: 'Noto Serif Hong Kong', name: `"Noto Serif HK", serif`, url: '/fonts/NotoSerifHongKong.woff2' },
+    { code: 'Noto Sans Japanese', name: `"Noto Sans JP", sans-serif`, url: '/fonts/NotoSansJapanese.woff2' },
+    { code: 'Noto Sans Korean', name: `"Noto Sans KR", sans-serif`, url: '/fonts/NotoSansKorean.woff2' },
+    { code: 'Poppins', name: `"Poppins", sans-serif`, url: '/fonts/Poppins.woff2' }
+];
+const FONT_KEY = 'OPEN_FONTS';
+const FONT_VERSION_KEY = 'OPEN_FONTS_VERSION';
+class FontManager {
+    constructor() {
+        this.fontList = [];
+        this.skipLoadFonts = exports.defaultFonts.map((value) => value.name);
+        this.loadFonts = exports.defaultFonts;
+        this.initFonts();
+    }
+    async initFonts() {
+        let list = [];
+        if (typeof localStorage !== 'undefined') {
+            if (localStorage.getItem(FONT_VERSION_KEY) !== '1') {
+                localStorage.removeItem(FONT_KEY);
+            }
+            let localFonts = [];
+            try {
+                const storedFonts = localStorage.getItem(FONT_KEY);
+                localFonts = storedFonts ? JSON.parse(storedFonts) : [];
+            }
+            catch {
+                localFonts = [];
+                localStorage.removeItem(FONT_KEY);
+            }
+            if (localFonts.length > 0) {
+                list.push(...localFonts);
+            }
+        }
+        this.fontList = exports.defaultFonts.concat(list);
+        return list;
+    }
+    getFontList() {
+        return this.fontList;
+    }
+    getSkipLoadFonts() {
+        return this.skipLoadFonts;
+    }
+    getLoadFonts() {
+        return this.loadFonts;
+    }
+}
+exports.FontManager = FontManager;
+exports.fontManager = new FontManager();

package/dist/fonts/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function fetchFontAsBase64(url: string): Promise<string>;
+export declare function addCustomFonts(fontList?: any): void;
+export declare function getCustomFontsStyle(): string;
+export declare function addCustomFont(font: any): void;
+export declare function batchLoadFont(fontNameList?: any): Promise<void>;
+export declare function addCustomFontBase64(font: any): Promise<void>;
+export declare function getBase64CustomFontsStyle(): string;
+export declare function loadFont(font: string): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/fonts/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/fonts/utils.ts"],"names":[],"mappings":"AAGA,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAsCpE;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,GAAE,GAAQ,QAShD;AAKD,wBAAgB,mBAAmB,WAGlC;AAMD,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,QAgCtC;AAMD,wBAAsB,aAAa,CAAC,YAAY,GAAE,GAAQ,iBAUzD;AAyCD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,GAAG,iBA6ClD;AAKD,wBAAgB,yBAAyB,WAGxC;AAOD,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1D"}

package/dist/fonts/utils.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFontAsBase64 = fetchFontAsBase64;
+exports.addCustomFonts = addCustomFonts;
+exports.getCustomFontsStyle = getCustomFontsStyle;
+exports.addCustomFont = addCustomFont;
+exports.batchLoadFont = batchLoadFont;
+exports.addCustomFontBase64 = addCustomFontBase64;
+exports.getBase64CustomFontsStyle = getBase64CustomFontsStyle;
+exports.loadFont = loadFont;
+const FONT_CSS_TAG = "data-fonts";
+const FONT_CSS_TAG_BASE64 = "base64-fonts";
+async function fetchFontAsBase64(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch font from ${url}`);
+    }
+    const contentType = response.headers.get('Content-Type');
+    let mimeType;
+    if (contentType?.includes('font/woff2')) {
+        mimeType = 'font/woff2';
+    }
+    else if (contentType?.includes('font/woff')) {
+        mimeType = 'font/woff';
+    }
+    else if (contentType?.includes('font/ttf') || contentType?.includes('font/sfnt')) {
+        mimeType = 'font/ttf';
+    }
+    else if (contentType?.includes('application/octet-stream')) {
+        const extension = url.split('.').pop()?.toLowerCase();
+        if (extension === 'woff2') {
+            mimeType = 'font/woff2';
+        }
+        else if (extension === 'woff') {
+            mimeType = 'font/woff';
+        }
+        else if (extension === 'ttf') {
+            mimeType = 'font/ttf';
+        }
+        else {
+            throw new Error(`Unsupported font file type: ${extension}`);
+        }
+    }
+    else {
+        throw new Error(`Unsupported Content-Type: ${contentType}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const base64String = arrayBufferToBase64(arrayBuffer);
+    return `data:${mimeType};charset=utf-8;base64,${base64String}`;
+}
+function arrayBufferToBase64(buffer) {
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+}
+function addCustomFonts(fontList = []) {
+    let styleTag = document.createElement('style');
+    styleTag.setAttribute(FONT_CSS_TAG, 'true');
+    let fontRules = fontList.map((font) => `@font-face {
+        font-family: "${font.name}";
+        src: local("${font.name}"), url("${font.download}")
+    }`).join('\n');
+    styleTag.textContent = fontRules;
+    document.head.appendChild(styleTag);
+}
+function getCustomFontsStyle() {
+    const styleTag = document.querySelector('style[data-fonts]');
+    return styleTag?.textContent || '';
+}
+function addCustomFont(font) {
+    let styleTag = document.querySelector('style[data-fonts]');
+    if (!styleTag) {
+        styleTag = document.createElement('style');
+        styleTag.setAttribute(FONT_CSS_TAG, 'true');
+        document.head.appendChild(styleTag);
+    }
+    if (!styleTag.sheet)
+        return;
+    let existingFonts = [];
+    existingFonts = Array.from(styleTag.sheet.cssRules).map((rule) => {
+        const match = rule.cssText.match(/font-family: "([^"]+)"/);
+        return match ? match[1] : null;
+    }).filter((font) => font !== null);
+    if (!existingFonts.includes(font.name)) {
+        const newFontRule = `@font-face {
+          font-family: "${font.name}";
+          src: url("${font.download}");
+        }`;
+        try {
+            styleTag.sheet.insertRule(newFontRule, styleTag.sheet.cssRules.length);
+        }
+        catch (e) {
+            console.error('Failed to insert font rule:', e);
+        }
+    }
+}
+async function batchLoadFont(fontNameList = []) {
+    try {
+        for (const fontFamily of fontNameList) {
+            await document.fonts.load(`16px ${fontFamily}`);
+        }
+    }
+    catch (e) {
+        console.warn('Font loading failed:', e);
+    }
+}
+function getFontUrlFromCSS(selectors, fontFamilyName) {
+    const styleTags = document.querySelectorAll(selectors);
+    for (let i = 0; i < styleTags.length; i++) {
+        const styleTag = styleTags[i];
+        const cssText = styleTag.textContent || '';
+        const fontFaceRules = cssText.match(/@font-face\s*\{[^}]+\}/g);
+        if (fontFaceRules) {
+            for (const rule of fontFaceRules) {
+                const fontFamilyMatch = rule.match(/font-family:\s*(["'])(.*?)\1/);
+                if (fontFamilyMatch && fontFamilyMatch[2] === fontFamilyName) {
+                    const srcMatch = rule.match(/src:\s*url\((["'])(.*?)\1\)/);
+                    if (srcMatch) {
+                        return srcMatch[2];
+                    }
+                    else {
+                        const srcMatch2 = rule.match(/src:\s*(?:local\([^)]+\)\s*,\s*)?url\((["'])(.*?)\1\)/);
+                        if (srcMatch2) {
+                            return srcMatch2[2];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+async function addCustomFontBase64(font) {
+    const fontUrl = getFontUrlFromCSS(`style[${FONT_CSS_TAG}]`, font);
+    if (!fontUrl) {
+        console.warn('Font URL not found for:', font);
+        return;
+    }
+    console.log('fontUrl=', fontUrl);
+    let styleTag = document.querySelector(`style[${FONT_CSS_TAG_BASE64}]`);
+    if (!styleTag) {
+        styleTag = document.createElement('style');
+        styleTag.setAttribute(FONT_CSS_TAG_BASE64, 'true');
+        document.head.appendChild(styleTag);
+    }
+    if (!styleTag.sheet) {
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+    if (!styleTag.sheet)
+        return;
+    let existingFonts = Array.from(styleTag.sheet.cssRules).map((rule) => {
+        const match = rule.cssText.match(/font-family: "([^"]+)"/);
+        return match ? match[1] : null;
+    }).filter((font) => font !== null);
+    if (!existingFonts.includes(font)) {
+        const base64Url = await fetchFontAsBase64(fontUrl);
+        const newFontRule = `@font-face {
+          font-family: "${font}";
+          src: local("${font}"), url("${base64Url}");
+        }`;
+        try {
+            styleTag.sheet.insertRule(newFontRule, styleTag.sheet.cssRules.length);
+            styleTag.textContent += newFontRule;
+        }
+        catch (e) {
+            console.error('Failed to insert font rule:', e);
+        }
+    }
+}
+function getBase64CustomFontsStyle() {
+    const styleTag = document.querySelector(`style[${FONT_CSS_TAG_BASE64}]`);
+    return styleTag?.textContent || '';
+}
+async function loadFont(font) {
+    await addCustomFontBase64(font);
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { TextEditor } from "./TextEditor";
+import "./TextEditTool";
+import "quill/dist/quill.core.css";
+export { updataHtmlText, setHTMLText } from "./utils";
+export { fontManager, defaultFonts, FontManager } from "./fonts/font";
+export declare function initTextEditorQuill(container?: HTMLElement): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,gBAAgB,CAAC;AAIxB,OAAO,2BAA2B,CAAC;AAGnC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAItE,wBAAgB,mBAAmB,CAAC,SAAS,CAAC,EAAE,WAAW,OA6E1D"}

package/dist/index.esm.js

@@ -0,0 +1,79 @@
+import { TextEditor } from "./TextEditor";
+export { TextEditor } from "./TextEditor";
+import "./TextEditTool";
+import { Plugin } from "@leafer-ui/core";
+import { Delta } from "quill";
+import Quill from "quill";
+import "quill/dist/quill.core.css";
+export { updataHtmlText, setHTMLText } from "./utils";
+export { fontManager, defaultFonts, FontManager } from "./fonts/font";
+Plugin.add("leafer-htmltext-editor", "editor");
+export function initTextEditorQuill(container) {
+    const textInner = document.getElementById("textInnerEditor");
+    if (!textInner) {
+        const el = document.createElement("div");
+        el.id = "textInnerEditor";
+        el.style.position = "fixed";
+        el.style.transformOrigin = "left top";
+        el.style.overflowWrap = "break-word";
+        el.style.wordBreak = "break-all";
+        el.style.visibility = "hidden";
+        document.body.appendChild(el);
+    }
+    TextEditor.quill = new Quill("#textInnerEditor", {
+        theme: null,
+        modules: {
+            toolbar: false,
+            keyboard: {
+                bindings: {
+                    enter: {
+                        key: "Enter",
+                        handler: (range, context) => {
+                            const [line] = TextEditor.quill.getLine(range.index);
+                            const BlockBlot = Quill.import("blots/block");
+                            if (!BlockBlot || !BlockBlot.bubbleFormats)
+                                return;
+                            const lineFormats = BlockBlot.bubbleFormats(line);
+                            const delta = new Delta()
+                                .retain(range.index)
+                                .delete(range.length)
+                                .insert("\n", lineFormats);
+                            TextEditor.quill.updateContents(delta, Quill.sources.USER);
+                            TextEditor.quill.setSelection(range.index + 1, Quill.sources.SILENT);
+                            return false;
+                        },
+                    },
+                },
+            },
+        },
+    });
+    const FontAttributor = Quill.import("attributors/class/font");
+    FontAttributor.whitelist = [
+        "Roboto",
+        "RobotoMono",
+        "Inter",
+        "OpenSans",
+        "Montserrat",
+        "RobotoCondensed",
+        "Arimo",
+        "NotoSans",
+        "NotoSansSymbols",
+        "Merriweather",
+        "PlayfairDisplay",
+        "NotoSerif",
+        "Lato",
+        "Spectral",
+        "DancingScript",
+        "NotoSansSimplifiedChinese",
+        "NotoSerifSimplifiedChinese",
+        "NotoSansTraditionalChinese",
+        "NotoSansHongKong",
+        "NotoSerifTraditionalChinese",
+        "NotoSerifHongKong",
+        "NotoSansJapanese",
+        "NotoSansKorean",
+        "Poppins",
+    ];
+    Quill.register(FontAttributor, true);
+    return TextEditor.quill;
+}