[Init] Initial commit - NetMesh terminal manager

lib/localFonts.ts

@@ -0,0 +1,222 @@
+import { TerminalFont } from "../infrastructure/config/fonts"
+
+/**
+ * Type definition for Local Font Access API
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Local_Font_Access_API
+ */
+interface LocalFontData {
+    family: string;
+}
+
+/**
+ * Known monospace font families that don't follow naming conventions.
+ * These are popular programming/terminal fonts that should be included.
+ */
+const KNOWN_MONOSPACE_FONTS = new Set([
+    // Popular programming fonts
+    'iosevka',
+    'hack',
+    'consolas',
+    'menlo',
+    'monaco',
+    'inconsolata',
+    'mononoki',
+    'fantasque sans mono',
+    'anonymous pro',
+    'liberation mono',
+    'dejavu sans mono',
+    'droid sans mono',
+    'ubuntu mono',
+    'roboto mono',
+    'source code pro',
+    'fira code',
+    'fira mono',
+    'jetbrains mono',
+    'cascadia code',
+    'cascadia mono',
+    'victor mono',
+    'ibm plex mono',
+    'sf mono',
+    'operator mono',
+    'input mono',
+    'pragmata pro',
+    'berkeley mono',
+    'monaspace',
+    'geist mono',
+    'comic mono',
+    'courier',
+    'courier new',
+    'lucida console',
+    'pt mono',
+    'overpass mono',
+    'space mono',
+    'go mono',
+    'noto sans mono',
+    'sarasa mono',
+    'maple mono',
+    'meslolgs nf',
+    'symbols nerd font mono',
+    'symbols nerd font',
+]);
+
+/**
+ * Suffix indicators that suggest a font is monospace
+ */
+const MONO_SUFFIX_INDICATORS = ['mono', 'monospace', 'code', 'terminal', 'console'];
+
+/**
+ * Checks if a font family name indicates a monospace font.
+ * Uses both known font list and suffix matching for comprehensive detection.
+ */
+function isMonospaceFont(familyName: string): boolean {
+    const familyLower = familyName.toLowerCase().trim();
+    
+    // Check against known monospace fonts (exact or partial match)
+    for (const knownFont of KNOWN_MONOSPACE_FONTS) {
+        if (familyLower === knownFont || familyLower.startsWith(knownFont + ' ')) {
+            return true;
+        }
+    }
+    
+    // Check suffix indicators with word boundary
+    return MONO_SUFFIX_INDICATORS.some(indicator => {
+        return (
+            familyLower === indicator ||
+            familyLower.endsWith(' ' + indicator) ||
+            familyLower.endsWith('-' + indicator) ||
+            familyLower.includes(' ' + indicator + ' ')
+        );
+    });
+}
+
+// Cached unfiltered system family list so we don't hit the Local Font
+// Access API more than once per session. Populated as a side effect of
+// queryAllSystemFontsOnce(), which both getMonospaceFonts() and
+// fontAvailability.ts read.
+let allSystemFamiliesCache: Set<string> | null = null;
+let allSystemFamilyNamesCache: string[] | null = null;
+
+// In-flight promise dedup: when fontStore.initialize() runs
+// getMonospaceFonts() and getAllSystemFontFamilies() in parallel, both
+// would otherwise hit queryLocalFonts() before the cache is populated,
+// causing two redundant Local Font Access API calls and potential
+// permission-handling races. Caching the promise itself means
+// concurrent callers await the same single invocation.
+let queryPromise: Promise<LocalFontData[]> | null = null;
+
+/** Clears the cached font query so a user-initiated refresh sees changes. */
+export function clearLocalFontsCache(): void {
+    queryPromise = null;
+    allSystemFamiliesCache = null;
+    allSystemFamilyNamesCache = null;
+}
+
+/** Test alias kept explicit so existing tests communicate their intent. */
+export const __resetLocalFontsCacheForTesting = clearLocalFontsCache;
+
+function queryAllSystemFontsOnce(): Promise<LocalFontData[]> {
+    if (queryPromise) return queryPromise;
+    queryPromise = (async () => {
+        if (typeof window === "undefined" || !("queryLocalFonts" in window)) {
+            return [];
+        }
+        try {
+            const queryLocalFonts = (window as unknown as {
+                queryLocalFonts: () => Promise<LocalFontData[]>;
+            }).queryLocalFonts;
+            const fonts = await queryLocalFonts();
+            // A desktop OS always has fonts. Chromium can still resolve the
+            // API with an empty list when access is temporarily unavailable;
+            // do not treat that as authoritative or cache it for the session.
+            if (fonts.length === 0) {
+                queryPromise = null;
+                return [];
+            }
+            const familyNamesByLower = new Map<string, string>();
+            for (const font of fonts) {
+                const family = font.family.trim();
+                if (!family) continue;
+                const normalized = family.toLowerCase();
+                if (!familyNamesByLower.has(normalized)) {
+                    familyNamesByLower.set(normalized, family);
+                }
+            }
+            allSystemFamilyNamesCache = [...familyNamesByLower.values()].sort((a, b) =>
+                a.localeCompare(b, undefined, { sensitivity: 'base' }),
+            );
+            allSystemFamiliesCache = new Set(familyNamesByLower.keys());
+            return fonts;
+        } catch (error) {
+            // Don't sticky-cache a transient failure (e.g. LFA permission
+            // not ready yet at app boot, AbortError, etc.). Clearing the
+            // module-level promise lets the very next caller retry the
+            // API. Successful calls keep their cached promise as before,
+            // so this only retries when something actually went wrong.
+            console.warn('Failed to query local fonts:', error);
+            queryPromise = null;
+            return [];
+        }
+    })();
+    return queryPromise;
+}
+
+/**
+ * Returns the case-insensitive set of every font family installed on the
+ * system, as reported by the Local Font Access API. Used by
+ * fontAvailability.ts to decide which built-in font choices to show in
+ * the dropdown.
+ *
+ * Returns null when the API is unavailable or permission has been
+ * denied — callers should treat that as "no authoritative data" and
+ * fall back to canvas-width detection.
+ */
+export async function getAllSystemFontFamilies(): Promise<Set<string> | null> {
+    if (allSystemFamiliesCache) return allSystemFamiliesCache;
+    await queryAllSystemFontsOnce();
+    return allSystemFamiliesCache;
+}
+
+/**
+ * Returns installed font family names with display casing preserved.
+ * Families are trimmed, deduplicated case-insensitively, and sorted for
+ * stable searchable pickers.
+ */
+export async function getAllSystemFontFamilyNames(): Promise<string[] | null> {
+    if (allSystemFamilyNamesCache) return allSystemFamilyNamesCache;
+    await queryAllSystemFontsOnce();
+    return allSystemFamilyNamesCache;
+}
+
+/**
+ * Queries local monospace fonts from the system using the Font Access API.
+ * Returns an empty array if the API is not available or permission is denied.
+ */
+export async function getMonospaceFonts(): Promise<TerminalFont[]> {
+    const fonts = await queryAllSystemFontsOnce();
+    if (fonts.length === 0) return [];
+
+    // Filter monospace fonts using robust word boundary matching
+    const monoFonts = fonts.filter(f => isMonospaceFont(f.family));
+
+    // Deduplicate by family name, case-insensitive (API may return multiple entries per family)
+    const uniqueFamilies = new Set<string>();
+    const dedupedFonts = monoFonts.filter(f => {
+        const key = f.family.toLowerCase();
+        if (uniqueFamilies.has(key)) return false;
+        uniqueFamilies.add(key);
+        return true;
+    });
+
+    // Raw Latin family only; CJK fallback is composed at runtime by
+    // composeFontFamilyStack() in cjkFonts.ts.
+    return dedupedFonts.map(f => {
+        const quoted = /\s/.test(f.family) ? `"${f.family}"` : f.family;
+        return {
+            id: f.family,
+            name: f.family,
+            family: `${quoted}, monospace`,
+            description: `Local font: ${f.family}`,
+            category: 'monospace' as const,
+        };
+    });
+}