[Init] Initial commit - NetMesh terminal manager

lib/fontWeightAvailability.ts

@@ -0,0 +1,104 @@
+import { extractPrimaryFamily } from './fontAvailability';
+
+/** Weights actually shipped via @fontsource in index.tsx. */
+export const BUNDLED_FONT_WEIGHTS: Readonly<Record<string, readonly number[]>> = {
+  'JetBrains Mono': [400, 500, 600],
+};
+
+export type FontWeightMeasureContext = {
+  measureText: (font: string, text: string) => TextMetrics;
+};
+
+const BOLD_PROBE = 'WMwm0123456789';
+
+export function pickNearestBundledWeight(
+  available: readonly number[],
+  desired: number,
+  normal: number,
+): number {
+  if (available.includes(desired)) return desired;
+  const heavier = available.filter((weight) => weight > normal);
+  if (heavier.length === 0) return normal;
+  return heavier.reduce((best, weight) =>
+    Math.abs(weight - desired) < Math.abs(best - desired) ? weight : best,
+  );
+}
+
+/**
+ * True when rendering `boldWeight` produces measurably different glyphs than
+ * `normalWeight` for `family`. Unlike document.fonts.check(), this does not
+ * false-positive on syntactically valid but unavailable families/weights in
+ * Chromium (see fontAvailability.ts).
+ */
+export function isBoldWeightDistinctWithContext(
+  family: string,
+  normalWeight: number,
+  boldWeight: number,
+  fontSize: number,
+  ctx: FontWeightMeasureContext,
+): boolean {
+  if (boldWeight <= normalWeight) return false;
+
+  const quoted = /\s/.test(family) ? `"${family}"` : family;
+  const normalFont = `${normalWeight} ${fontSize}px ${quoted}, monospace`;
+  const boldFont = `${boldWeight} ${fontSize}px ${quoted}, monospace`;
+
+  const normalMetrics = ctx.measureText(normalFont, BOLD_PROBE);
+  const boldMetrics = ctx.measureText(boldFont, BOLD_PROBE);
+
+  if (Math.abs(boldMetrics.width - normalMetrics.width) > 0.01) return true;
+
+  const normalAscent = normalMetrics.actualBoundingBoxAscent ?? 0;
+  const boldAscent = boldMetrics.actualBoundingBoxAscent ?? 0;
+  if (Math.abs(boldAscent - normalAscent) > 0.01) return true;
+
+  const normalDescent = normalMetrics.actualBoundingBoxDescent ?? 0;
+  const boldDescent = boldMetrics.actualBoundingBoxDescent ?? 0;
+  return Math.abs(boldDescent - normalDescent) > 0.01;
+}
+
+function buildBrowserMeasureContext(): FontWeightMeasureContext | null {
+  if (typeof document === 'undefined') return null;
+  const canvas = document.createElement('canvas');
+  const ctx = canvas.getContext('2d');
+  if (!ctx) return null;
+  return {
+    measureText: (font, text) => {
+      ctx.font = font;
+      return ctx.measureText(text);
+    },
+  };
+}
+
+/**
+ * Resolve the boldest weight xterm can safely rasterize for the primary font.
+ * Falls back to `normalWeight` when the requested bold face is unavailable.
+ */
+export function resolveFontWeightBold(args: {
+  fontFamilyCss: string;
+  normalWeight: number;
+  desiredBoldWeight: number;
+  fontSize: number;
+}): number {
+  const { fontFamilyCss, normalWeight, desiredBoldWeight, fontSize } = args;
+  if (desiredBoldWeight <= normalWeight) return normalWeight;
+
+  const primary = extractPrimaryFamily(fontFamilyCss);
+  const bundled = BUNDLED_FONT_WEIGHTS[primary];
+  if (bundled) {
+    return pickNearestBundledWeight(bundled, desiredBoldWeight, normalWeight);
+  }
+
+  const ctx = buildBrowserMeasureContext();
+  if (!ctx) return desiredBoldWeight;
+
+  return isBoldWeightDistinctWithContext(
+    primary,
+    normalWeight,
+    desiredBoldWeight,
+    fontSize,
+    ctx,
+  )
+    ? desiredBoldWeight
+    : normalWeight;
+}