mod-build 4.0.82 → 4.0.83-beta.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 4.0.83
+
+- Updated `grab-global-fonts` task to grab fonts from `gwfh.mranftl.com/api/fonts` -- will default to `Roboto` unless defined in `siteconfig.js` = `fontsToDownload: ['font-name']` 
+
 ## 4.0.82
 
 - Added `grab-global-fonts` task to grab Roboto + Montserrat font files from mod-site

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mod-build",
-	"version": "4.0.82",
+	"version": "4.0.83-beta.2",
 	"description": "Share components for S3 sites.",
 	"type": "module",
 	"scripts": {

package/tasks/add-files-to-gitignore.js

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 /**
- * Adds entries to .gitignore file (always appends to bottom)
+ * Adds entries to .gitignore file
+ * If a section with the same comment exists, adds entries below it; otherwise, appends to bottom
  * @param {string[]} entries - Array of entries to add to .gitignore
  * @param {string} comment - Optional comment to add before the entries
  * @returns {Promise<void>}
@@ -27,17 +28,33 @@ export default async function addFilesToGitignore(entries, comment) {
 		return;
 	}
 
-	// Build content to append with proper spacing
-	let contentToAppend = content.trim() 
-		? (content.endsWith('\n') ? '\n' : '\n\n')
-		: '';
-
+	// If comment exists, find the section and insert below it
 	if (comment) {
-		contentToAppend += `# ${comment}\n`;
+		const commentLine = `# ${comment}`;
+		const lines = content.split('\n');
+		const sectionIndex = lines.findIndex(line => line.trim() === commentLine);
+
+		if (sectionIndex !== -1) {
+			let insertIndex = sectionIndex + 1;
+			let lastNonBlankIndex = sectionIndex;
+			
+			while (insertIndex < lines.length && !lines[insertIndex].trim().startsWith('#')) {
+				if (lines[insertIndex].trim() !== '') {
+					lastNonBlankIndex = insertIndex;
+				}
+				insertIndex++;
+			}
+
+			lines.splice(lastNonBlankIndex + 1, 0, ...entriesToAppend);
+			await fs.promises.writeFile(gitignorePath, lines.join('\n') + '\n', 'utf8');
+			console.log(`Added to .gitignore ${comment} section: ${entriesToAppend.join(', ')}`);
+			return;
+		}
 	}
-	contentToAppend += entriesToAppend.join('\n') + '\n';
 
-	await fs.promises.appendFile(gitignorePath, contentToAppend, 'utf8');
-	console.log(`Added to .gitignore: ${entriesToAppend.join(', ')}`);
-}
+	const separator = content.trim() ? (content.endsWith('\n') ? '\n' : '\n\n') : '';
+	const newContent = comment ? `${separator}# ${comment}\n${entriesToAppend.join('\n')}\n` : `${separator}${entriesToAppend.join('\n')}\n`;
 
+	await fs.promises.appendFile(gitignorePath, newContent, 'utf8');
+	console.log(`Added to .gitignore: ${entriesToAppend.join(', ')}`);
+}

package/tasks/clean.js

@@ -1,9 +1,17 @@
 import fs from 'fs';
 
-const foldersToDelete = ['./src/resources', './src/accessible-components', './src/shared-components', './src/.tmp', './src/temp', './public/resources', './jsdoc-types', './public/fonts/montserrat', './public/fonts/roboto'];
+const baseFoldersToDelete = ['./src/resources', './src/accessible-components', './src/shared-components', './src/.tmp', './src/temp', './public/resources', './jsdoc-types'];
 
 const filesToDelete = ['./modform.jsdoc.js'];
 
+// We will want to delete all downloaded fonts (which will be all folders but ./public/fonts/branded/*)
+const fontBaseFolder = './public/fonts';
+const fontFoldersToDelete = fs.readdirSync(fontBaseFolder, { withFileTypes: true })
+	.filter(dirent => dirent.isDirectory() && dirent.name !== 'branded')
+	.map(dirent => path.join(fontBaseFolder, dirent.name));
+
+const foldersToDelete = [...baseFoldersToDelete, ...fontFoldersToDelete];
+
 foldersToDelete.forEach(async (folder) => {
 	try {
 		await fs.promises.rm(folder, { recursive: true });

package/tasks/grab-global-fonts.js

@@ -4,74 +4,147 @@ import { createWriteStream } from 'node:fs';
 import * as stream from 'node:stream';
 import { promisify } from 'node:util';
 import fs from 'node:fs';
+import path from 'node:path';
 import { responseInterceptor } from '../src/scripts/retry-axios.js';
 import addFilesToGitignore from './add-files-to-gitignore.js';
 
-const resourcePath = 'quote/resources/mod-site/fonts';
-
-// Global font names
-const fontNames = [
-	'roboto',
-	'montserrat'
-];
-
 // Font variants and extensions to download for each font
 const fontVariants = ['regular', 'bold'];
 const fontExtensions = ['ttf', 'woff2'];
 
-// Generate array of all font files needed for download
-const fontFiles = fontNames.flatMap(fontName => {
-	return fontVariants.flatMap(variant => {
-		return fontExtensions.map(ext => {
-			return `${fontName}/${fontName}-${variant}.${ext}`;
-		});
-	});
-});
-
 const axiosInstance = axios.create();
 responseInterceptor(axiosInstance);
 
-const streamFontToDestination = (defaultSettings, fontPath) => {
+const directoryHasItems = (dirPath) => {
+	if (!fs.existsSync(dirPath)) {
+		return false;
+	}
+	const items = fs.readdirSync(dirPath);
+	return items.length > 0;
+};
+
+const getFontDownloadUrls = async (fontName) => {
+	try {
+		const url = `https://gwfh.mranftl.com/api/fonts/${fontName}?subsets=latin`;
+		const response = await axiosInstance.get(url);
+		const fontData = response.data;
+		
+		if (!fontData || !fontData.variants) {
+			throw new Error('Invalid font data received');
+		}
+		
+		const downloadUrls = {};
+		
+		const targetWeights = ['400', '700'];
+		
+		fontData.variants.forEach(variant => {
+			if (variant.fontStyle === 'normal' && targetWeights.includes(variant.fontWeight)) {
+				const variantName = variant.fontWeight === '400' ? 'regular' : 'bold';
+				
+				if (!downloadUrls[variantName]) {
+					downloadUrls[variantName] = {};
+				}
+				
+				if (variant.ttf) {
+					downloadUrls[variantName].ttf = variant.ttf;
+				}
+				if (variant.woff2) {
+					downloadUrls[variantName].woff2 = variant.woff2;
+				}
+			}
+		});
+		
+		return downloadUrls;
+	} catch (error) {
+		console.error(`Error fetching font data for ${fontName}:`, error.message);
+		throw error;
+	}
+};
+
+const downloadFontFile = async (defaultSettings, fontName, variant, extension, downloadUrl) => {
 	const finished = promisify(stream.finished);
 
-	return new Promise(resolve => {
-		const filePath = `${defaultSettings.publicFolder}/${defaultSettings.fontsSubfolder}/${fontPath}`;
-		const folderPath = filePath.split('/').slice(0, -1).join('/');
+	return new Promise((resolve, reject) => {
+		const fileName = `${fontName}-${variant}.${extension}`;
+		const filePath = path.join(
+			defaultSettings.publicFolder,
+			defaultSettings.fontsSubfolder,
+			fontName,
+			fileName
+		);
+		const folderPath = path.dirname(filePath);
 
-		// Create directory if it doesn't exist
 		if (!fs.existsSync(folderPath)) {
 			fs.mkdirSync(folderPath, { recursive: true });
 		}
 
-		// if file exists, do not create it again
 		if (fs.existsSync(filePath)) {
+			console.log(`${filePath} already exists, skipping...`);
 			resolve();
-		} else {
-			const writer = createWriteStream(filePath);
-			const options = {
-				url: `https://${defaultSettings.nodeEnv}/${resourcePath}/${fontPath}`,
-				method: 'get',
-				responseType: 'stream'
-			};
-
-			axios(options).then(resp => {
+			return;
+		}
+
+		const writer = createWriteStream(filePath);
+
+		axiosInstance({
+			url: downloadUrl,
+			method: 'get',
+			responseType: 'stream'
+		})
+			.then(resp => {
 				if (resp.status !== 200) {
-					throw new Error(`${resp.status}: Error while fetching ${options.url}`);
+					throw new Error(`${resp.status}: Error while fetching ${downloadUrl}`);
 				}
-				console.log(`${filePath} copied...`);
+				console.log(`Downloading ${filePath}...`);
 				resp.data.pipe(writer);
 				return finished(writer);
-			}).then(() => {
+			})
+			.then(() => {
+				console.log(`${filePath} downloaded successfully`);
 				resolve();
-			}).catch(error => {
-				console.error(error);
-				throw new Error(`${error?.response?.statusText} [${error?.status}]: Error while fetching ${options.url}`);
+			})
+			.catch(error => {
+				console.error(`Error downloading ${filePath} from ${downloadUrl}:`, error.message);
+				reject(new Error(`Failed to download ${filePath}: ${error.message}`));
 			});
-		}
 	});
 };
 
-const updateGitignore = async () => {
+const downloadFont = async (defaultSettings, fontName) => {
+	const fontDir = path.join(
+		defaultSettings.publicFolder,
+		defaultSettings.fontsSubfolder,
+		fontName
+	);
+
+	if (directoryHasItems(fontDir)) {
+		console.log(`Font directory ${fontDir} already has items, skipping ${fontName}...`);
+		return;
+	}
+
+	console.log(`Downloading font: ${fontName}`);
+
+	const downloadUrls = await getFontDownloadUrls(fontName);
+	
+	if (!downloadUrls || Object.keys(downloadUrls).length === 0) {
+		throw new Error(`Could not find download URLs for ${fontName}`);
+	}
+
+	const downloadPromises = fontVariants.flatMap(variant => {
+		return fontExtensions.map(ext => {
+			const url = downloadUrls[variant]?.[ext];
+			if (!url) {
+				console.warn(`Warning: No ${ext} URL found for ${fontName} ${variant}, skipping...`);
+				return Promise.resolve();
+			}
+			return downloadFontFile(defaultSettings, fontName, variant, ext, url);
+		});
+	});
+
+	await Promise.all(downloadPromises);
+};
+
+const updateGitignore = async (defaultSettings, fontNames) => {
 	const fontEntries = fontNames.map(fontName => 
 		`${defaultSettings.publicFolder}/${defaultSettings.fontsSubfolder}/${fontName}/`
 	);
@@ -79,19 +152,23 @@ const updateGitignore = async () => {
 	await addFilesToGitignore(fontEntries, 'Global fonts');
 };
 
-export default function() {
-	const fontsPath = `${defaultSettings.publicFolder}/${defaultSettings.fontsSubfolder}`;
+// If a site has a branded font that is outside of this API - we should add it to /public/fonts/branded/{fontName}/*
+export default function(config) {
+	// Download fonts from config.fontsToDownload or will default to ['roboto']
+	const fontNames = config?.fontsToDownload && Array.isArray(config.fontsToDownload) && config.fontsToDownload.length > 0
+		? config.fontsToDownload
+		: ['roboto'];
+
+	const fontsPath = path.join(defaultSettings.publicFolder, defaultSettings.fontsSubfolder);
 	if (!fs.existsSync(fontsPath)) {
 		fs.mkdirSync(fontsPath, { recursive: true });
 	}
 
-	// Download all font files
-	const fontPromises = fontFiles.map(fontPath => {
-		return streamFontToDestination(defaultSettings, fontPath);
+	const fontPromises = fontNames.map(fontName => {
+		return downloadFont(defaultSettings, fontName);
 	});
 
 	return Promise.all(fontPromises).then(async () => {
-		// Update .gitignore after fonts are downloaded
-		await updateGitignore();
+		await updateGitignore(defaultSettings, fontNames);
 	});
-}
+}

package/tasks/serve.js

@@ -13,7 +13,7 @@ import { createStylelintFile, updateConfig } from '../src/scripts/plugins.js';
 export async function startModBuild(config) {
 	addEditorConfig();
 	createStylelintFile();
-	grabGlobalFonts();
+	grabGlobalFonts(config);
 	await grabB2BData(config);
 	await grabCdn(config);
 	await getDefaultTradeQuestions(config);