kritzel-stencil 0.4.4 → 0.4.6

package/dist/components/p-DJkKlUyZ.js

@@ -1 +1,182 @@
-const t="__kritzelFontRegistry__",e="kritzel-font-registry-change",s=t=>t.trim().toLocaleLowerCase();class n{static get _fonts(){return(()=>{const e=globalThis,s=e[t];if(s)return s;const n={fonts:new Map};return e[t]=n,n})().fonts}static getFontFaceSet(){return"undefined"!=typeof document&&document.fonts?document.fonts:null}static toCssFontFace(t){return t.includes(" ")?`"${t.replaceAll('"','\\"')}"`:t}static getRegisteredFontFamilies(t){return[...new Set(Object.values(t).map((t=>"string"==typeof t?t:t.family)).map((t=>t.trim())).filter(Boolean))]}static register(t,e){const s=((t,e)=>"string"==typeof e?{key:t,family:e,label:e,cssFontFamily:e}:{key:t,family:e.family,label:e.label??e.family,cssFontFamily:e.cssFontFamily??e.family,source:e.source})(t,e);this._fonts.has(t)&&console.warn(`[FontRegistry] Font "${t}" is already registered. It will be overwritten.`),this._fonts.set(t,s),this.emitChange()}static registerFonts(t){for(const[e,s]of Object.entries(t))this.register(e,s)}static injectFontStylesheets(t){if("undefined"==typeof document)return Promise.resolve([]);const e=[];for(const[s,n]of Object.entries(t)){if("string"==typeof n||!n.source)continue;const t=n.source,i=`kritzel-font-stylesheet-${s}`;if(document.getElementById(i))continue;const o=document.createElement("link");o.id=i,o.rel="stylesheet",o.href=t;const r=new Promise((e=>{o.onload=()=>e(),o.onerror=()=>{console.warn(`[FontRegistry] Failed to load stylesheet for font "${s}": ${t}`),e()}}));document.head.appendChild(o),e.push(r)}return Promise.all(e)}static async waitForFonts(t){await this.injectFontStylesheets(t);const e=this.getFontFaceSet(),s=this.getRegisteredFontFamilies(t);e&&0!==s.length&&(await Promise.allSettled(s.map((t=>e.load(`1em ${this.toCssFontFace(t)}`)))),await e.ready)}static get(t){return this._fonts.get(t)}static has(t){return this._fonts.has(t)}static unregister(t){const e=this._fonts.delete(t);return e&&this.emitChange(),e}static list(){return[...this._fonts.values()]}static resolveCssFontFamily(t){const e=s(t),n=this.list().find((t=>s(t.family)===e||t.key.trim().toLocaleLowerCase()===e));return n?.cssFontFamily??t}static toRegisteredFont(t){return"string"==typeof t?{key:t,family:t,label:t,cssFontFamily:t}:{key:t.family,family:t.family,label:t.label??t.family,cssFontFamily:t.cssFontFamily??t.family,source:t.source}}static emitChange(){const t=globalThis;"function"==typeof t.dispatchEvent&&"undefined"!=typeof CustomEvent&&t.dispatchEvent(new CustomEvent(e))}static get changeEventName(){return e}}const i=["Arial","Verdana","Helvetica","Tahoma","Trebuchet MS","Times New Roman","Georgia","Garamond","Courier New","Brush Script MT"],o=t=>t&&0!==t.length?[...t]:[...i];export{i as D,n as K,o as r}
+const KRITZEL_FONT_REGISTRY_KEY = '__kritzelFontRegistry__';
+const KRITZEL_FONT_REGISTRY_EVENT = 'kritzel-font-registry-change';
+const getGlobalRegistryStore = () => {
+    const globalScope = globalThis;
+    const existing = globalScope[KRITZEL_FONT_REGISTRY_KEY];
+    if (existing) {
+        return existing;
+    }
+    const created = {
+        fonts: new Map(),
+    };
+    globalScope[KRITZEL_FONT_REGISTRY_KEY] = created;
+    return created;
+};
+const normalizeFontRegistration = (key, registration) => {
+    if (typeof registration === 'string') {
+        return {
+            key,
+            family: registration,
+            label: registration,
+            cssFontFamily: registration,
+        };
+    }
+    return {
+        key,
+        family: registration.family,
+        label: registration.label ?? registration.family,
+        cssFontFamily: registration.cssFontFamily ?? registration.family,
+        source: registration.source,
+    };
+};
+const normalizeKey = (value) => value.trim().toLocaleLowerCase();
+const normalizeFamily = (value) => value.trim().toLocaleLowerCase();
+class KritzelFontRegistry {
+    static get _fonts() {
+        return getGlobalRegistryStore().fonts;
+    }
+    static getFontFaceSet() {
+        if (typeof document === 'undefined' || !document.fonts) {
+            return null;
+        }
+        return document.fonts;
+    }
+    static toCssFontFace(fontFamily) {
+        return fontFamily.includes(' ')
+            ? `"${fontFamily.replaceAll('"', '\\"')}"`
+            : fontFamily;
+    }
+    static getRegisteredFontFamilies(fonts) {
+        return [...new Set(Object.values(fonts)
+                .map(registration => (typeof registration === 'string' ? registration : registration.family))
+                .map(family => family.trim())
+                .filter(Boolean))];
+    }
+    static register(key, registration) {
+        const normalized = normalizeFontRegistration(key, registration);
+        if (this._fonts.has(key)) {
+            console.warn(`[FontRegistry] Font "${key}" is already registered. It will be overwritten.`);
+        }
+        this._fonts.set(key, normalized);
+        this.emitChange();
+    }
+    static registerFonts(fonts) {
+        for (const [key, registration] of Object.entries(fonts)) {
+            this.register(key, registration);
+        }
+    }
+    static injectFontStylesheets(fonts) {
+        if (typeof document === 'undefined') {
+            return Promise.resolve([]);
+        }
+        const loadPromises = [];
+        for (const [key, registration] of Object.entries(fonts)) {
+            if (typeof registration === 'string' || !registration.source) {
+                continue;
+            }
+            const sourceUrl = registration.source;
+            const linkId = `kritzel-font-stylesheet-${key}`;
+            if (document.getElementById(linkId)) {
+                continue;
+            }
+            const link = document.createElement('link');
+            link.id = linkId;
+            link.rel = 'stylesheet';
+            link.href = sourceUrl;
+            const promise = new Promise((resolve) => {
+                link.onload = () => resolve();
+                link.onerror = () => {
+                    console.warn(`[FontRegistry] Failed to load stylesheet for font "${key}": ${sourceUrl}`);
+                    resolve(); // Resolve anyway so we don't hang startup on external failures
+                };
+            });
+            document.head.appendChild(link);
+            loadPromises.push(promise);
+        }
+        return Promise.all(loadPromises);
+    }
+    static async waitForFonts(fonts) {
+        await this.injectFontStylesheets(fonts);
+        const fontFaceSet = this.getFontFaceSet();
+        const registeredFontFamilies = this.getRegisteredFontFamilies(fonts);
+        if (!fontFaceSet || registeredFontFamilies.length === 0) {
+            return;
+        }
+        await Promise.allSettled(registeredFontFamilies.map(fontFamily => fontFaceSet.load(`1em ${this.toCssFontFace(fontFamily)}`)));
+        await fontFaceSet.ready;
+    }
+    static get(key) {
+        return this._fonts.get(key);
+    }
+    static has(key) {
+        return this._fonts.has(key);
+    }
+    static unregister(key) {
+        const deleted = this._fonts.delete(key);
+        if (deleted) {
+            this.emitChange();
+        }
+        return deleted;
+    }
+    static list() {
+        return [...this._fonts.values()];
+    }
+    static resolveCssFontFamily(fontFamily) {
+        const normalizedFamily = normalizeFamily(fontFamily);
+        const match = this.list().find(font => {
+            if (normalizeFamily(font.family) === normalizedFamily) {
+                return true;
+            }
+            return normalizeKey(font.key) === normalizedFamily;
+        });
+        return match?.cssFontFamily ?? fontFamily;
+    }
+    static toRegisteredFont(registration) {
+        if (typeof registration === 'string') {
+            return {
+                key: registration,
+                family: registration,
+                label: registration,
+                cssFontFamily: registration,
+            };
+        }
+        return {
+            key: registration.family,
+            family: registration.family,
+            label: registration.label ?? registration.family,
+            cssFontFamily: registration.cssFontFamily ?? registration.family,
+            source: registration.source,
+        };
+    }
+    static emitChange() {
+        const eventTarget = globalThis;
+        if (typeof eventTarget.dispatchEvent !== 'function' || typeof CustomEvent === 'undefined') {
+            return;
+        }
+        eventTarget.dispatchEvent(new CustomEvent(KRITZEL_FONT_REGISTRY_EVENT));
+    }
+    static get changeEventName() {
+        return KRITZEL_FONT_REGISTRY_EVENT;
+    }
+}
+
+const DEFAULT_TEXT_TOOL_AVAILABLE_FONTS = [
+    'Arial',
+    'Verdana',
+    'Helvetica',
+    'Tahoma',
+    'Trebuchet MS',
+    'Times New Roman',
+    'Georgia',
+    'Garamond',
+    'Courier New',
+    'Brush Script MT',
+];
+const resolveTextToolAvailableFonts = (availableFonts) => {
+    if (!availableFonts || availableFonts.length === 0) {
+        return [...DEFAULT_TEXT_TOOL_AVAILABLE_FONTS];
+    }
+    return [...availableFonts];
+};
+
+export { DEFAULT_TEXT_TOOL_AVAILABLE_FONTS as D, KritzelFontRegistry as K, resolveTextToolAvailableFonts as r };