@timber-js/app 0.2.0-alpha.4 → 0.2.0-alpha.6

package/dist/index.js

@@ -1,7 +1,7 @@
-import { r as setViteServer, t as formatSize } from "./_chunks/format-CwdaB0_2.js";
+import { r as setViteServer, t as formatSize } from "./_chunks/format-DviM89f0.js";
 import { i as scanRoutes, n as generateRouteMap, t as collectInterceptionRewrites } from "./_chunks/interception-BOoWmLUA.js";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, extname, join, resolve } from "node:path";
+import { dirname, extname, join, normalize, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import react from "@vitejs/plugin-react";
@@ -11953,12 +11953,14 @@ function generateConfigModule(ctx) {
 * extensions as timber.config.ts detection.
 */
 function detectInstrumentationFile(root) {
-	for (const ext of [
+	const extensions = [
 		".ts",
 		".js",
 		".mjs"
-	]) {
-		const candidate = resolve(root, `instrumentation${ext}`);
+	];
+	const dirs = [root, resolve(root, "src")];
+	for (const dir of dirs) for (const ext of extensions) {
+		const candidate = resolve(dir, `instrumentation${ext}`);
 		if (existsSync(candidate)) return candidate;
 	}
 	return null;
@@ -12018,17 +12020,20 @@ function timberEntries(ctx) {
 //#region src/plugins/mdx.ts
 var MDX_EXTENSIONS = ["mdx", "md"];
 /**
-* Check if mdx-components.tsx (or .ts, .jsx, .js) exists at the project root.
+* Check if mdx-components.tsx (or .ts, .jsx, .js) exists at the project root
+* or in src/. Root takes precedence, matching Next.js behavior.
 * Returns the absolute path if found, otherwise undefined.
 */
 function findMdxComponents(root) {
-	for (const name of [
+	const candidates = [
 		"mdx-components.tsx",
 		"mdx-components.ts",
 		"mdx-components.jsx",
 		"mdx-components.js"
-	]) {
-		const p = join(root, name);
+	];
+	const dirs = [root, join(root, "src")];
+	for (const dir of dirs) for (const name of candidates) {
+		const p = join(dir, name);
 		if (existsSync(p)) return p;
 	}
 }
@@ -12542,6 +12547,58 @@ export const coerce = stub;
 	};
 }
 //#endregion
+//#region src/fonts/css.ts
+/**
+* Generate a single `@font-face` CSS rule from a descriptor.
+*/
+function generateFontFace(desc) {
+	const lines = [];
+	lines.push("@font-face {");
+	lines.push(`  font-family: '${desc.family}';`);
+	lines.push(`  src: ${desc.src};`);
+	if (desc.weight) lines.push(`  font-weight: ${desc.weight};`);
+	if (desc.style) lines.push(`  font-style: ${desc.style};`);
+	if (desc.display) lines.push(`  font-display: ${desc.display};`);
+	if (desc.unicodeRange) lines.push(`  unicode-range: ${desc.unicodeRange};`);
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* Generate multiple `@font-face` rules from an array of descriptors.
+*/
+function generateFontFaces(descriptors) {
+	return descriptors.map(generateFontFace).join("\n\n");
+}
+/**
+* Generate a scoped CSS class that sets a CSS custom property for the font.
+*
+* Example output:
+* ```css
+* .timber-font-inter {
+*   --font-sans: 'Inter', 'Inter Fallback', system-ui, sans-serif;
+* }
+* ```
+*/
+function generateVariableClass(className, variable, fontFamily) {
+	return `.${className} {\n  ${variable}: ${fontFamily};\n}`;
+}
+/**
+* Generate a scoped CSS class that applies font-family directly.
+*
+* Used when no `variable` is specified — the className applies
+* the font-family inline instead of through a CSS custom property.
+*
+* Example output:
+* ```css
+* .timber-font-inter {
+*   font-family: 'Inter', 'Inter Fallback', system-ui, sans-serif;
+* }
+* ```
+*/
+function generateFontFamilyClass(className, fontFamily) {
+	return `.${className} {\n  font-family: ${fontFamily};\n}`;
+}
+//#endregion
 //#region src/fonts/fallbacks.ts
 /**
 * Lookup table for commonly used Google Fonts.
@@ -12680,6 +12737,26 @@ function getGenericFamily(family) {
 	return "sans-serif";
 }
 /**
+* Generate the full CSS for a size-adjusted fallback font.
+*
+* This produces a complete @font-face block with override descriptors
+* that FontFaceDescriptor doesn't natively support.
+*/
+function generateFallbackCss(family) {
+	const metrics = FALLBACK_METRICS[family.toLowerCase()];
+	if (!metrics) return null;
+	return [
+		"@font-face {",
+		`  font-family: '${`${family} Fallback`}';`,
+		`  src: local('${metrics.fallbackFont}');`,
+		`  size-adjust: ${metrics.sizeAdjust}%;`,
+		`  ascent-override: ${metrics.ascentOverride}%;`,
+		`  descent-override: ${metrics.descentOverride}%;`,
+		`  line-gap-override: ${metrics.lineGapOverride}%;`,
+		"}"
+	].join("\n");
+}
+/**
 * Check whether fallback metrics are available for a font family.
 */
 function hasFallbackMetrics(family) {
@@ -13028,6 +13105,26 @@ function generateFamilyName(sources) {
 	return stem.replace(/[-_]?(Regular|Bold|Italic|Light|Medium|SemiBold|ExtraBold|Thin|Black|Heavy)$/i, "") || stem;
 }
 /**
+* Generate @font-face descriptors for local font sources.
+*
+* Each source entry produces one @font-face rule. The `src` descriptor
+* uses a `url()` pointing to the served path under `/_timber/fonts/`.
+* The `urlPrefix` defaults to `/_timber/fonts` — the path used by both
+* the dev server middleware and the production build output.
+*/
+function generateLocalFontFaces(family, sources, display, urlPrefix = "/_timber/fonts") {
+	return sources.map((entry) => {
+		const format = inferFontFormat(entry.path);
+		return {
+			family,
+			src: `url('${urlPrefix}/${entry.path.split("/").pop() ?? entry.path}') format('${format}')`,
+			weight: entry.weight,
+			style: entry.style,
+			display
+		};
+	});
+}
+/**
 * Build the className for a local font, following the same convention
 * as Google fonts: `timber-font-<lowercase-hyphenated-family>`.
 */
@@ -13260,8 +13357,10 @@ async function isCacheHit(metaPath, dataPath) {
 //#region src/plugins/fonts.ts
 var VIRTUAL_GOOGLE = "@timber/fonts/google";
 var VIRTUAL_LOCAL = "@timber/fonts/local";
+var VIRTUAL_FONT_CSS = "virtual:timber-fonts.css";
 var RESOLVED_GOOGLE = "\0@timber/fonts/google";
 var RESOLVED_LOCAL = "\0@timber/fonts/local";
+var RESOLVED_FONT_CSS = "\0virtual:timber-fonts.css";
 /**
 * Convert a font family name to a PascalCase export name.
 * e.g. "JetBrains Mono" → "JetBrains_Mono"
@@ -13409,6 +13508,26 @@ function generateLocalVirtualModule() {
 	].join("\n");
 }
 /**
+* Generate the CSS output for all extracted fonts.
+*
+* Includes @font-face rules for local fonts, fallback @font-face rules,
+* and scoped classes.
+*/
+function generateAllFontCss(registry) {
+	const cssParts = [];
+	for (const font of registry.values()) {
+		if (font.provider === "local" && font.localSources) {
+			const faceCss = generateFontFaces(generateLocalFontFaces(font.family, font.localSources, font.display));
+			if (faceCss) cssParts.push(faceCss);
+		}
+		const fallbackCss = generateFallbackCss(font.family);
+		if (fallbackCss) cssParts.push(fallbackCss);
+		if (font.variable) cssParts.push(generateVariableClass(font.className, font.variable, font.fontFamily));
+		else cssParts.push(generateFontFamilyClass(font.className, font.fontFamily));
+	}
+	return cssParts.join("\n\n");
+}
+/**
 * Parse the local name used for the default import of `@timber/fonts/local`.
 *
 * Handles:
@@ -13461,13 +13580,52 @@ function timberFonts(ctx) {
 		resolveId(id) {
 			if (id === VIRTUAL_GOOGLE) return RESOLVED_GOOGLE;
 			if (id === VIRTUAL_LOCAL) return RESOLVED_LOCAL;
+			if (id === VIRTUAL_FONT_CSS) return RESOLVED_FONT_CSS;
 			return null;
 		},
 		load(id) {
 			if (id === RESOLVED_GOOGLE) return generateGoogleVirtualModule(registry);
 			if (id === RESOLVED_LOCAL) return generateLocalVirtualModule();
+			if (id === RESOLVED_FONT_CSS) return generateAllFontCss(registry);
 			return null;
 		},
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				const url = req.url;
+				if (!url || !url.startsWith("/_timber/fonts/")) return next();
+				const requestedFilename = url.slice(15);
+				if (requestedFilename.includes("..") || requestedFilename.includes("/")) {
+					res.statusCode = 400;
+					res.end("Bad request");
+					return;
+				}
+				for (const font of registry.values()) {
+					if (font.provider !== "local" || !font.localSources) continue;
+					for (const src of font.localSources) if ((src.path.split("/").pop() ?? "") === requestedFilename) {
+						const absolutePath = normalize(resolve(src.path));
+						if (!existsSync(absolutePath)) {
+							res.statusCode = 404;
+							res.end("Not found");
+							return;
+						}
+						const data = readFileSync(absolutePath);
+						const ext = absolutePath.split(".").pop()?.toLowerCase();
+						res.setHeader("Content-Type", {
+							woff2: "font/woff2",
+							woff: "font/woff",
+							ttf: "font/ttf",
+							otf: "font/otf",
+							eot: "application/vnd.ms-fontopen"
+						}[ext ?? ""] ?? "application/octet-stream");
+						res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+						res.setHeader("Access-Control-Allow-Origin", "*");
+						res.end(data);
+						return;
+					}
+				}
+				next();
+			});
+		},
 		async buildStart() {
 			if (ctx.dev) return;
 			const googleFonts = [...registry.values()].filter((f) => f.provider === "google");
@@ -13523,10 +13681,13 @@ function timberFonts(ctx) {
 				}
 			}
 			if (hasLocalImport) transformedCode = transformLocalFonts(transformedCode, code, id, registry, this.error.bind(this));
-			if (transformedCode !== code) return {
-				code: transformedCode,
-				map: null
-			};
+			if (transformedCode !== code) {
+				transformedCode = `import '${VIRTUAL_FONT_CSS}';\n` + transformedCode;
+				return {
+					code: transformedCode,
+					map: null
+				};
+			}
 			return null;
 		},
 		generateBundle() {
@@ -13535,6 +13696,29 @@ function timberFonts(ctx) {
 				fileName: `_timber/fonts/${cf.hashedFilename}`,
 				source: cf.data
 			});
+			for (const font of registry.values()) {
+				if (font.provider !== "local" || !font.localSources) continue;
+				for (const src of font.localSources) {
+					const absolutePath = normalize(resolve(src.path));
+					if (!existsSync(absolutePath)) {
+						this.warn(`Local font file not found: ${absolutePath}`);
+						continue;
+					}
+					const basename = src.path.split("/").pop() ?? src.path;
+					const data = readFileSync(absolutePath);
+					this.emitFile({
+						type: "asset",
+						fileName: `_timber/fonts/${basename}`,
+						source: data
+					});
+				}
+			}
+			const fontCss = generateAllFontCss(registry);
+			if (fontCss) this.emitFile({
+				type: "asset",
+				fileName: "_timber/fonts/fonts.css",
+				source: fontCss
+			});
 			if (!ctx.buildManifest) return;
 			const cachedByFamily = /* @__PURE__ */ new Map();
 			for (const cf of cachedFonts) {