astrotype 0.1.2 → 0.1.3

package/cli/commands/add-font.mjs

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { getFontByName } from "../lib/registry.mjs";
 import {
-  buildFontImports,
+  ensureAstroFontsApiSetup,
   isAstroProject,
   writeAstrotypeCss,
 } from "../lib/add-utils.mjs";
@@ -30,10 +30,18 @@ export async function addFontCommand(fontName, options = {}) {
     process.exit(1);
   }
 
-  const fontImports = buildFontImports([font]);
-  const cssText = `${fontImports}
-
-${toCssRules(font)}`;
+  const cssText = `${toCssRules(font)}`;
   const cssPath = writeAstrotypeCss(targetDir, font.name, cssText);
+  const fontsSetup = ensureAstroFontsApiSetup(targetDir, [font]);
   console.log(`Installed font "${font.name}" into ${path.relative(targetDir, cssPath)}.`);
+  if (fontsSetup.configured) {
+    console.log("Configured Astro Fonts API entries for this font.");
+    if (fontsSetup.manualMergeRequired) {
+      console.log(
+        `Detected an existing fonts config in ${path.relative(targetDir, fontsSetup.configPath)}; merge astrotypeFonts manually there.`
+      );
+    }
+  } else {
+    console.log(`Skipped Astro Fonts API setup: ${fontsSetup.reason}`);
+  }
 }

package/cli/commands/add.mjs

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { getFontByName, getPairingByName } from "../lib/registry.mjs";
 import {
-  buildFontImports,
+  ensureAstroFontsApiSetup,
   isAstroProject,
   writeAstrotypeCss,
 } from "../lib/add-utils.mjs";
@@ -40,14 +40,22 @@ export async function addPairingCommand(pairingName, options = {}) {
     process.exit(1);
   }
 
-  const fontImports = buildFontImports(fonts);
-  const cssText = `${fontImports}
-
-${toCssRules(pairing.css)}
+  const cssText = `${toCssRules(pairing.css)}
 `;
   const pairingCssPath = writeAstrotypeCss(targetDir, pairing.name, cssText);
+  const fontsSetup = ensureAstroFontsApiSetup(targetDir, fonts);
 
   console.log(`Installed pairing "${pairing.name}" into ${path.relative(targetDir, pairingCssPath)}.`);
+  if (fontsSetup.configured) {
+    console.log("Configured Astro Fonts API entries for this pairing.");
+    if (fontsSetup.manualMergeRequired) {
+      console.log(
+        `Detected an existing fonts config in ${path.relative(targetDir, fontsSetup.configPath)}; merge astrotypeFonts manually there.`
+      );
+    }
+  } else {
+    console.log(`Skipped Astro Fonts API setup: ${fontsSetup.reason}`);
+  }
   console.log("No Tailwind color utilities are required; styles are CSS-token driven.");
 }
 

package/cli/lib/add-utils.mjs

@@ -22,28 +22,140 @@ export function isAstroProject(targetDir) {
   );
 }
 
-export function buildFontImports(fontEntries) {
-  const lines = [];
-  for (const font of fontEntries) {
-    if (!font) continue;
-    if (font.font.provider === "npm" && font.font.npmPackage === "geist") {
-      if (font.name === "geist") lines.push('@import "geist/font/sans.css";');
-      if (font.name === "geist-mono") lines.push('@import "geist/font/mono.css";');
-      continue;
-    }
-    if (font.font.dependency) {
-      lines.push(`@import "${font.font.dependency}";`);
-      continue;
-    }
-    if (font.font.provider === "google") {
-      lines.push(
-        `@import url("https://fonts.googleapis.com/css2?family=${encodeURIComponent(
-          font.title
-        ).replace(/%20/g, "+")}:wght@400;500;600;700&display=swap");`
-      );
+function toAstroFontDescriptor(font) {
+  if (!font?.font?.provider) return null;
+  const provider = String(font.font.provider).toLowerCase();
+  const cssVariable = font.font.variable || `--font-${font.name}`;
+  if (provider === "google") {
+    return {
+      name: font.name,
+      familyName: font.title,
+      cssVariable,
+      provider: "google",
+      options: null,
+    };
+  }
+  if (provider === "npm") {
+    const npmPackage = font.font.npmPackage || font.font.package;
+    if (!npmPackage) return null;
+    let file = null;
+    if (npmPackage === "geist") {
+      if (font.name === "geist") file = "font/sans.css";
+      if (font.name === "geist-mono") file = "font/mono.css";
     }
+    return {
+      name: font.name,
+      familyName: font.title,
+      cssVariable,
+      provider: "npm",
+      options: {
+        package: npmPackage,
+        ...(file ? { file } : {}),
+      },
+    };
+  }
+  return null;
+}
+
+function serializeAstroFontDescriptor(descriptor) {
+  const optionsLine = descriptor.options
+    ? `,\n    options: ${JSON.stringify(descriptor.options)}`
+    : "";
+  return `  {
+    provider: fontProviders.${descriptor.provider}(),
+    name: ${JSON.stringify(descriptor.familyName)},
+    cssVariable: ${JSON.stringify(descriptor.cssVariable)}${optionsLine}
+  }`;
+}
+
+function getAstroConfigPath(targetDir) {
+  const astroConfigCandidates = [
+    "astro.config.mjs",
+    "astro.config.js",
+    "astro.config.ts",
+    "astro.config.cjs",
+  ];
+  for (const file of astroConfigCandidates) {
+    const filePath = path.join(targetDir, file);
+    if (fs.existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+
+function ensureAstroConfigHasAstrotypeImport(configText) {
+  const importLine = 'import { astrotypeFonts } from "./src/astrotypes/fonts.mjs";';
+  if (configText.includes(importLine)) return configText;
+  const defineConfigImportRegex = /import\s*\{[^}]*defineConfig[^}]*\}\s*from\s*["']astro\/config["'];?\n?/;
+  const match = configText.match(defineConfigImportRegex);
+  if (!match) return configText;
+  return configText.replace(match[0], `${match[0]}${importLine}\n`);
+}
+
+function ensureAstroConfigHasFontsProperty(configText) {
+  if (/\bfonts\s*:/.test(configText)) return { text: configText, injected: false };
+  let next = configText.replace(
+    /defineConfig\(\s*\{/,
+    "defineConfig({\n  fonts: astrotypeFonts,"
+  );
+  next = next.replace(/fonts: astrotypeFonts,\s*\}\);/m, "fonts: astrotypeFonts,\n});");
+  return { text: next, injected: next !== configText };
+}
+
+export function ensureAstroFontsApiSetup(targetDir, fontEntries) {
+  const descriptors = fontEntries.map(toAstroFontDescriptor).filter(Boolean);
+  if (descriptors.length === 0) {
+    return {
+      configured: false,
+      reason: "No compatible providers found for Astro Fonts API.",
+    };
+  }
+
+  const astrotypeDir = path.join(targetDir, "src", "astrotypes");
+  ensureDir(astrotypeDir);
+  const statePath = path.join(astrotypeDir, "fonts.state.json");
+  const prior = fs.existsSync(statePath)
+    ? JSON.parse(fs.readFileSync(statePath, "utf-8"))
+    : [];
+  const byVariable = new Map();
+  for (const entry of prior) {
+    if (entry?.cssVariable) byVariable.set(entry.cssVariable, entry);
   }
-  return [...new Set(lines)].join("\n");
+  for (const descriptor of descriptors) {
+    byVariable.set(descriptor.cssVariable, descriptor);
+  }
+  const merged = [...byVariable.values()].sort((a, b) =>
+    a.cssVariable.localeCompare(b.cssVariable)
+  );
+  fs.writeFileSync(statePath, `${JSON.stringify(merged, null, 2)}\n`);
+
+  const modulePath = path.join(astrotypeDir, "fonts.mjs");
+  const lines = merged.map((entry) => serializeAstroFontDescriptor(entry)).join(",\n");
+  const moduleText = `import { fontProviders } from "astro/config";
+
+export const astrotypeFonts = [
+${lines}
+];
+`;
+  fs.writeFileSync(modulePath, moduleText);
+
+  const astroConfigPath = getAstroConfigPath(targetDir);
+  if (!astroConfigPath) {
+    return {
+      configured: false,
+      reason: "No astro.config.* file found.",
+    };
+  }
+
+  let configText = fs.readFileSync(astroConfigPath, "utf-8");
+  configText = ensureAstroConfigHasAstrotypeImport(configText);
+  const result = ensureAstroConfigHasFontsProperty(configText);
+  fs.writeFileSync(astroConfigPath, result.text);
+
+  return {
+    configured: true,
+    configPath: astroConfigPath,
+    manualMergeRequired: !result.injected && /\bfonts\s*:/.test(configText),
+  };
 }
 
 export function ensureImport(globalCssPath, importLine) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "astrotype",
   "description": "Astro-first font registry and CLI for installing pairings or single fonts.",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "private": false,
   "keywords": [
     "astro",