chore: import upstream snapshot with attribution

packages/studio-server/src/routes/fonts.ts

@@ -0,0 +1,172 @@
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+import type { Hono } from "hono";
+import {
+  collectFontFileEntries,
+  fontDirectories,
+  getSystemProfilerFamilies,
+  locateSystemFont,
+  SYSTEM_FONT_SIZE_LIMIT,
+} from "@hyperframes/core/fonts/system-locator";
+
+const MAX_FONT_RESULTS = 2000;
+const GOOGLE_FONTS_METADATA_URL = "https://fonts.google.com/metadata/fonts";
+const GOOGLE_FONTS_FETCH_TIMEOUT_MS = 3000;
+let cachedFonts: string[] | null = null;
+let cachedGoogleFonts: string[] | null = null;
+
+const GOOGLE_FONT_FALLBACKS = [
+  "Inter",
+  "Roboto",
+  "Open Sans",
+  "Montserrat",
+  "Poppins",
+  "Lato",
+  "Oswald",
+  "Raleway",
+  "Nunito",
+  "Playfair Display",
+  "Merriweather",
+  "Source Sans 3",
+  "Source Serif 4",
+  "Source Code Pro",
+  "DM Sans",
+  "Space Grotesk",
+  "Space Mono",
+  "Bebas Neue",
+  "Outfit",
+  "JetBrains Mono",
+];
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function collectFontsFromDir(dir: string): string[] {
+  return collectFontFileEntries(dir).map((e) => e.family);
+}
+
+function listInstalledFontFamilies(): string[] {
+  if (cachedFonts) return cachedFonts;
+  const families = new Set<string>();
+
+  for (const family of getSystemProfilerFamilies()) {
+    families.add(family);
+    if (families.size >= MAX_FONT_RESULTS) break;
+  }
+
+  for (const dir of fontDirectories()) {
+    for (const family of collectFontsFromDir(dir)) {
+      families.add(family);
+      if (families.size >= MAX_FONT_RESULTS) break;
+    }
+    if (families.size >= MAX_FONT_RESULTS) break;
+  }
+
+  cachedFonts = Array.from(families).sort((a, b) => a.localeCompare(b));
+  return cachedFonts;
+}
+
+function parseGoogleFontMetadata(value: unknown): string[] {
+  if (!isRecord(value) || !Array.isArray(value.familyMetadataList)) return [];
+  const families: string[] = [];
+  for (const entry of value.familyMetadataList) {
+    if (!isRecord(entry) || typeof entry.family !== "string") continue;
+    families.push(entry.family);
+  }
+  return families;
+}
+
+function stripGoogleJsonGuard(raw: string): string {
+  const prefix = ")]}'";
+  if (!raw.startsWith(prefix)) return raw;
+
+  let index = prefix.length;
+  while (
+    index < raw.length &&
+    (raw[index] === " " ||
+      raw[index] === "\n" ||
+      raw[index] === "\r" ||
+      raw[index] === "\t" ||
+      raw[index] === "\f")
+  ) {
+    index += 1;
+  }
+
+  return raw.slice(index);
+}
+
+async function listGoogleFontFamilies(): Promise<string[]> {
+  if (cachedGoogleFonts) return cachedGoogleFonts;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), GOOGLE_FONTS_FETCH_TIMEOUT_MS);
+
+  try {
+    const response = await fetch(GOOGLE_FONTS_METADATA_URL, { signal: controller.signal });
+    if (!response.ok) {
+      cachedGoogleFonts = GOOGLE_FONT_FALLBACKS;
+      return cachedGoogleFonts;
+    }
+    const raw = await response.text();
+    const jsonText = stripGoogleJsonGuard(raw);
+    const families = parseGoogleFontMetadata(JSON.parse(jsonText));
+    cachedGoogleFonts = families.length > 0 ? families : GOOGLE_FONT_FALLBACKS;
+  } catch {
+    cachedGoogleFonts = GOOGLE_FONT_FALLBACKS;
+  } finally {
+    clearTimeout(timer);
+  }
+
+  return cachedGoogleFonts;
+}
+
+export function registerFontRoutes(api: Hono): void {
+  api.get("/fonts", (c) => c.json({ fonts: listInstalledFontFamilies() }));
+  api.get("/fonts/google", async (c) => c.json({ fonts: await listGoogleFontFamilies() }));
+
+  // fallow-ignore-next-line complexity
+  api.get("/fonts/file", (c) => {
+    const family = c.req.query("family");
+    if (!family) return c.json({ error: "family parameter required" }, 400);
+
+    const located = locateSystemFont(family);
+    if (!located) return c.json({ error: "font not found" }, 404);
+
+    let fd: number;
+    try {
+      fd = openSync(located.path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    } catch {
+      return c.json({ error: "font file not accessible" }, 404);
+    }
+    try {
+      const stat = fstatSync(fd);
+      if (stat.size > SYSTEM_FONT_SIZE_LIMIT) {
+        return c.json({ error: "font file too large" }, 413);
+      }
+      const buffer = Buffer.alloc(stat.size);
+      readSync(fd, buffer, 0, stat.size, 0);
+      const mimeType =
+        located.format === "otf"
+          ? "font/otf"
+          : located.format === "woff2"
+            ? "font/woff2"
+            : located.format === "woff"
+              ? "font/woff"
+              : located.format === "ttc"
+                ? "font/collection"
+                : "font/ttf";
+
+      const fileName = `${family.replace(/[^a-zA-Z0-9 -]/g, "")}.${located.format}`;
+      return new Response(buffer, {
+        headers: {
+          "Content-Type": mimeType,
+          "Content-Disposition": `attachment; filename="${fileName}"`,
+        },
+      });
+    } catch {
+      return c.json({ error: "failed to read font file" }, 500);
+    } finally {
+      closeSync(fd);
+    }
+  });
+}