blume 1.5.2 → 1.6.0

package/src/theme/fonts.ts

@@ -28,6 +28,11 @@ export interface RemoteFontConfig {
   provider?: RemoteFontProvider;
   /** Weights (or variable ranges like `"100..900"`) to load. Defaults to `[400, 500, 600, 700]`. */
   weights?: (number | string)[];
+  /**
+   * Character subsets to load (`"latin"`, `"vietnamese"`, `"cyrillic"`, …).
+   * Defaults to `latin` plus whatever the site's configured locales need.
+   */
+  subsets?: string[];
   /** Fallback stack category. Defaults to `"mono"` for the mono role, `"sans"` otherwise. */
   fallback?: FontCategory;
 }
@@ -72,6 +77,7 @@ export type FontEntry =
       cssVariable: string;
       fallbacks: string[];
       name: string;
+      subsets: string[];
       weights: (number | string)[];
     }
   | {
@@ -205,6 +211,129 @@ export const isFontSlug = (value: string): value is FontSlug =>
 /** Weights loaded for a remote family when the config does not pin them. */
 const DEFAULT_REMOTE_WEIGHTS: (number | string)[] = [400, 500, 600, 700];
 
+/**
+ * The subsets a language needs beyond `latin`, keyed by BCP 47 language
+ * subtag. Names are Google Fonts subsets (Bunny and Fontsource use the same
+ * ones). Languages whose alphabet fits Latin-1 — English, French, German,
+ * Spanish, … — need only `latin` and are absent. Keep keys alphabetical.
+ */
+const LOCALE_SUBSETS = {
+  az: ["latin-ext"],
+  ba: ["cyrillic", "cyrillic-ext"],
+  be: ["cyrillic"],
+  bg: ["cyrillic"],
+  bs: ["latin-ext"],
+  cs: ["latin-ext"],
+  cv: ["cyrillic", "cyrillic-ext"],
+  cy: ["latin-ext"],
+  el: ["greek"],
+  eo: ["latin-ext"],
+  et: ["latin-ext"],
+  ha: ["latin-ext"],
+  hr: ["latin-ext"],
+  hu: ["latin-ext"],
+  ig: ["latin-ext"],
+  kk: ["cyrillic", "cyrillic-ext"],
+  ku: ["latin-ext"],
+  ky: ["cyrillic", "cyrillic-ext"],
+  lt: ["latin-ext"],
+  lv: ["latin-ext"],
+  mk: ["cyrillic"],
+  mn: ["cyrillic", "cyrillic-ext"],
+  mt: ["latin-ext"],
+  pl: ["latin-ext"],
+  ro: ["latin-ext"],
+  ru: ["cyrillic"],
+  sk: ["latin-ext"],
+  sl: ["latin-ext"],
+  sr: ["cyrillic", "latin-ext"],
+  tg: ["cyrillic", "cyrillic-ext"],
+  tk: ["latin-ext"],
+  tr: ["latin-ext"],
+  tt: ["cyrillic", "cyrillic-ext"],
+  uk: ["cyrillic"],
+  uz: ["cyrillic", "latin-ext"],
+  vi: ["vietnamese"],
+  yo: ["latin-ext"],
+} satisfies Record<string, string[]>;
+
+/** Type guard: does `language` have an entry in the subset table? */
+const isSubsetLanguage = (
+  language: string
+): language is keyof typeof LOCALE_SUBSETS =>
+  Object.hasOwn(LOCALE_SUBSETS, language);
+
+/**
+ * Subsets a script subtag (`sr-Latn`, `az-Cyrl`) asks for on its own, so a
+ * locale written in a script its language doesn't default to still loads it.
+ */
+const SCRIPT_SUBSETS = {
+  cyrl: ["cyrillic"],
+  latn: ["latin-ext"],
+} satisfies Record<string, string[]>;
+
+/** Type guard: does `script` have an entry in the script table? */
+const isSubsetScript = (
+  script: string
+): script is keyof typeof SCRIPT_SUBSETS =>
+  Object.hasOwn(SCRIPT_SUBSETS, script);
+
+/** Google's listing order; keeps generated configs stable across runs. */
+const SUBSET_ORDER = [
+  "latin",
+  "latin-ext",
+  "vietnamese",
+  "cyrillic",
+  "cyrillic-ext",
+  "greek",
+  "greek-ext",
+];
+
+/** The shape of a config's `i18n` block the font builders read. */
+export interface FontLocaleSource {
+  locales: { code: string }[];
+}
+
+/** The locale codes an optional `i18n` block declares (none when absent). */
+export const fontLocaleCodes = (i18n: FontLocaleSource | undefined): string[] =>
+  i18n?.locales.map((locale) => locale.code) ?? [];
+
+/**
+ * The subsets the site's locales need: `latin` always, plus each locale's
+ * script. A site with no `i18n` block (or only Latin-1 languages) gets just
+ * `latin` — Astro's own default — so its CSS and preloads don't change.
+ */
+export const localeFontSubsets = (locales: string[]): string[] => {
+  const wanted = new Set(["latin"]);
+  for (const locale of locales) {
+    const [language = "", ...subtags] = locale.toLowerCase().split("-");
+    if (isSubsetLanguage(language)) {
+      for (const subset of LOCALE_SUBSETS[language]) {
+        wanted.add(subset);
+      }
+    }
+    for (const subtag of subtags) {
+      if (isSubsetScript(subtag)) {
+        for (const subset of SCRIPT_SUBSETS[subtag]) {
+          wanted.add(subset);
+        }
+      }
+    }
+  }
+  return SUBSET_ORDER.filter((subset) => wanted.has(subset));
+};
+
+/**
+ * Providers whose faces carry subset metadata, so `<Font preload>` can be
+ * filtered by subset. Fontshare serves whole files with no subset split; a
+ * subset filter there would match nothing and drop every preload.
+ */
+const SUBSET_PROVIDERS = new Set<RemoteFontProvider>([
+  "google",
+  "bunny",
+  "fontsource",
+]);
+
 /** Kebab-case a family name into a slug (`"Noto Sans JP"` -> `"noto-sans-jp"`). */
 export const slugifyFontName = (name: string): string =>
   name
@@ -227,10 +356,15 @@ const slotCategory = (slot: FontSlot): FontCategory =>
 const isSlugValue = (value: FontValue): value is string =>
   typeof value === "string";
 
-/** A slot value normalized into an entry, or null for an unknown slug string. */
+/**
+ * A slot value normalized into an entry, or null for an unknown slug string.
+ * `subsets` is the locale-derived default a remote family loads when the
+ * config does not pin its own.
+ */
 const resolveFontValue = (
   slot: FontSlot,
-  value: FontValue
+  value: FontValue,
+  subsets: string[]
 ): FontEntry | null => {
   if (isSlugValue(value)) {
     if (!isFontSlug(value)) {
@@ -243,6 +377,7 @@ const resolveFontValue = (
       kind: "remote",
       name: def.family,
       provider: "google",
+      subsets,
       weights: def.weights,
     };
   }
@@ -263,6 +398,7 @@ const resolveFontValue = (
     kind: "remote",
     name: value.name,
     provider: value.provider ?? "google",
+    subsets: value.subsets ?? subsets,
     weights: value.weights ?? DEFAULT_REMOTE_WEIGHTS,
   };
 };
@@ -282,6 +418,7 @@ const mergeFontEntries = (current: FontEntry, next: FontEntry): FontEntry => {
   ) {
     return {
       ...current,
+      subsets: [...new Set([...current.subsets, ...next.subsets])],
       weights: [...new Set([...current.weights, ...next.weights])],
     };
   }
@@ -298,18 +435,26 @@ const mergeFontEntries = (current: FontEntry, next: FontEntry): FontEntry => {
   );
 };
 
-/** The unique Astro `fonts:` entries for the configured roles (deduped). */
-export const buildFontEntries = (fonts: FontsConfig): FontEntry[] => {
+/**
+ * The unique Astro `fonts:` entries for the configured roles (deduped).
+ * `locales` are the site's configured locale codes; they pick the subsets a
+ * remote family loads unless its config pins `subsets` itself.
+ */
+export const buildFontEntries = (
+  fonts: FontsConfig,
+  locales: string[] = []
+): FontEntry[] => {
   if (!fonts) {
     return [];
   }
+  const subsets = localeFontSubsets(locales);
   const entries = new Map<string, FontEntry>();
   for (const slot of SLOTS) {
     const value = fonts[slot];
     if (value === undefined) {
       continue;
     }
-    const entry = resolveFontValue(slot, value);
+    const entry = resolveFontValue(slot, value, subsets);
     if (!entry) {
       continue;
     }
@@ -365,9 +510,15 @@ const PRELOAD_WEIGHTS = {
   mono: [400],
 } satisfies Record<FontSlot, number[]>;
 
-/** One `<Font>` render in the head: its CSS variable + weights to preload. */
+/**
+ * One `<Font>` render in the head: its CSS variable + the weights (and, for
+ * providers that split faces by subset, the subsets) to preload. Local and
+ * Fontshare faces carry no subset, so those entries leave `preloadSubsets`
+ * unset and preload by weight alone.
+ */
 export interface FontHead {
   cssVariable: string;
+  preloadSubsets?: string[];
   preloadWeights: number[];
 }
 
@@ -402,28 +553,50 @@ const preloadWeightsFor = (slot: FontSlot, entry: FontEntry): number[] => {
  * by CSS variable with preload weights unioned across the roles that share a
  * family (so `display` and `body` both set to Inter preload 400/500/600 once).
  */
-export const configuredFonts = (fonts: FontsConfig): FontHead[] => {
+export const configuredFonts = (
+  fonts: FontsConfig,
+  locales: string[] = []
+): FontHead[] => {
   if (!fonts) {
     return [];
   }
-  const heads = new Map<string, Set<number>>();
+  const defaultSubsets = localeFontSubsets(locales);
+  const heads = new Map<
+    string,
+    { subsets: Set<string> | null; weights: Set<number> }
+  >();
   for (const slot of SLOTS) {
     const value = fonts[slot];
     if (value === undefined) {
       continue;
     }
-    const entry = resolveFontValue(slot, value);
+    const entry = resolveFontValue(slot, value, defaultSubsets);
     if (!entry) {
       continue;
     }
-    const weights = heads.get(entry.cssVariable) ?? new Set();
+    const head = heads.get(entry.cssVariable) ?? {
+      subsets: null,
+      weights: new Set<number>(),
+    };
     for (const weight of preloadWeightsFor(slot, entry)) {
-      weights.add(weight);
+      head.weights.add(weight);
     }
-    heads.set(entry.cssVariable, weights);
+    if (entry.kind === "remote" && SUBSET_PROVIDERS.has(entry.provider)) {
+      head.subsets ??= new Set();
+      for (const subset of entry.subsets) {
+        head.subsets.add(subset);
+      }
+    }
+    heads.set(entry.cssVariable, head);
   }
-  return [...heads].map(([cssVariable, weights]) => ({
-    cssVariable,
-    preloadWeights: [...weights].toSorted((a, b) => a - b),
-  }));
+  return [...heads].map(([cssVariable, head]) => {
+    const font: FontHead = {
+      cssVariable,
+      preloadWeights: [...head.weights].toSorted((a, b) => a - b),
+    };
+    if (head.subsets) {
+      font.preloadSubsets = [...head.subsets];
+    }
+    return font;
+  });
 };

package/src/translate/prompts.ts

@@ -65,6 +65,8 @@ Rules:
 - Translate the prose: headings, paragraphs, list items, table cells, admonitions, and image alt text.
 - In the YAML frontmatter, translate ONLY the values of these keys: ${KEY_LIST}. Copy every other frontmatter key and value exactly as written.
 - Never translate or alter: code blocks, inline code, import/export statements, JSX/MDX component names and their attributes, URLs, link targets, HTML tags, or frontmatter keys.
+- A heading may end with anchor markers: \`[#some-id]\`, \`{#some-id}\` (also written \`\\{#some-id\\}\`), \`[!toc]\`, or \`[toc]\`. Copy every marker exactly as written, in the same position at the end of the translated heading — never translate, reorder, or drop a marker, and never change the id inside \`[#...]\` or \`{#...}\` (anchors must stay identical across languages).
+
 - Preserve the document structure exactly: the same headings, the same lists and tables, and the same number of code fences.${styleRule}${previousRule}
 - Output ONLY the complete translated file. Do not wrap it in a code fence. Do not add commentary before or after it.
 ${previousSection}

package/src/translate/run.ts

@@ -130,6 +130,13 @@ const runPageItem = async (
   });
 
   const sourceText = await readFile(item.sourcePath, "utf-8");
+  if (item.verbatim) {
+    // A non-markdown include partial (code embed) has no prose to translate;
+    // it's copied unchanged so the locale tree's relative includes resolve.
+    await writeTextAtomic(item.targetPath, sourceText);
+    stampLedger(ledger, item.sourceRel, item.locale, hashSource(sourceText));
+    return done("translated");
+  }
   // SAFETY: `targets` maps every configured locale, and work items only carry
   // configured locale codes.
   const target = context.targets.get(item.locale) as LocaleConfig;