mod-build 4.0.83 → 4.0.84

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 4.0.84
+
+- 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.83
 
 - Updated `grab-jsdoc` task to use correct resource path for mod-form

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mod-build",
-	"version": "4.0.83",
+	"version": "4.0.84",
 	"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,23 +1,32 @@
 import fs from 'fs';
+import path from 'path';
 
-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'];
 
-foldersToDelete.forEach(async (folder) => {
+// We will want to delete all downloaded fonts (which will be all folders but ./public/fonts/branded/*)
+const fontBaseFolder = './public/fonts';
+const fontFoldersToDelete = fs.existsSync(fontBaseFolder)
+	? fs.readdirSync(fontBaseFolder, { withFileTypes: true }).filter(dirent => dirent.isDirectory() && dirent.name !== 'branded').map(dirent => path.join(fontBaseFolder, dirent.name))
+	: [];
+
+const foldersToDelete = [...baseFoldersToDelete, ...fontFoldersToDelete];
+
+await Promise.all(foldersToDelete.map(async (folder) => {
 	try {
 		await fs.promises.rm(folder, { recursive: true });
 		console.log(`Folder ${folder} deleted successfully`);
 	} catch (err) {
 		// fail silently
 	}
-});
+}));
 
-filesToDelete.forEach(async (file) => {
+await Promise.all(filesToDelete.map(async (file) => {
 	try {
 		await fs.promises.rm(file);
 		console.log(`File ${file} deleted successfully`);
 	} catch (err) {
 		// fail silently
 	}
-});
+}));

package/tasks/grab-global-fonts.js

@@ -4,94 +4,145 @@ 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 finished = promisify(stream.finished);
 
 const axiosInstance = axios.create();
 responseInterceptor(axiosInstance);
 
-const streamFontToDestination = (defaultSettings, fontPath) => {
-	const finished = promisify(stream.finished);
+const getFontPath = (...parts) => path.join(
+	defaultSettings.publicFolder,
+	defaultSettings.fontsSubfolder,
+	...parts
+);
 
-	return new Promise(resolve => {
-		const filePath = `${defaultSettings.publicFolder}/${defaultSettings.fontsSubfolder}/${fontPath}`;
-		const folderPath = filePath.split('/').slice(0, -1).join('/');
+const directoryHasItems = (dirPath) => {
+	if (!fs.existsSync(dirPath)) {
+		return false;
+	}
+	return fs.readdirSync(dirPath).length > 0;
+};
 
-		// Create directory if it doesn't exist
-		if (!fs.existsSync(folderPath)) {
-			fs.mkdirSync(folderPath, { recursive: true });
+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?.variants) {
+			throw new Error('Invalid font data received');
 		}
-
-		// if file exists, do not create it again
-		if (fs.existsSync(filePath)) {
-			resolve();
-		} else {
-			const writer = createWriteStream(filePath);
-			const options = {
-				url: `https://${defaultSettings.nodeEnv}/${resourcePath}/${fontPath}`,
-				method: 'get',
-				responseType: 'stream'
-			};
-
-			axios(options).then(resp => {
-				if (resp.status !== 200) {
-					throw new Error(`${resp.status}: Error while fetching ${options.url}`);
+		
+		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';
+				downloadUrls[variantName] = downloadUrls[variantName] || {};
+				if (variant.ttf) {
+					downloadUrls[variantName].ttf = variant.ttf;
 				}
-				console.log(`${filePath} copied...`);
-				resp.data.pipe(writer);
-				return finished(writer);
-			}).then(() => {
-				resolve();
-			}).catch(error => {
-				console.error(error);
-				throw new Error(`${error?.response?.statusText} [${error?.status}]: Error while fetching ${options.url}`);
-			});
+				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 (fontName, variant, extension, downloadUrl) => {
+	const fileName = `${fontName}-${variant}.${extension}`;
+	const filePath = getFontPath(fontName, fileName);
+	const folderPath = path.dirname(filePath);
+
+	if (!fs.existsSync(folderPath)) {
+		fs.mkdirSync(folderPath, { recursive: true });
+	}
+
+	if (fs.existsSync(filePath)) {
+		console.log(`${filePath} already exists, skipping...`);
+		return;
+	}
+
+	try {
+		const resp = await axiosInstance({
+			url: downloadUrl,
+			method: 'get',
+			responseType: 'stream'
+		});
+
+		if (resp.status !== 200) {
+			throw new Error(`${resp.status}: Error while fetching ${downloadUrl}`);
 		}
-	});
+
+		console.log(`Downloading ${filePath}...`);
+		const writer = createWriteStream(filePath);
+		resp.data.pipe(writer);
+		await finished(writer);
+		console.log(`${filePath} downloaded successfully`);
+	} catch (error) {
+		console.error(`Error downloading ${filePath} from ${downloadUrl}:`, error.message);
+		throw new Error(`Failed to download ${filePath}: ${error.message}`);
+	}
 };
 
-const updateGitignore = async () => {
-	const fontEntries = fontNames.map(fontName => 
-		`${defaultSettings.publicFolder}/${defaultSettings.fontsSubfolder}/${fontName}/`
-	);
+const downloadFont = async (fontName) => {
+	const fontDir = getFontPath(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);
 	
-	await addFilesToGitignore(fontEntries, 'Global fonts');
+	if (!downloadUrls || Object.keys(downloadUrls).length === 0) {
+		throw new Error(`Could not find download URLs for ${fontName}`);
+	}
+
+	await Promise.all(
+		fontVariants.flatMap(variant =>
+			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(fontName, variant, ext, url);
+			})
+		)
+	);
 };
 
-export default function() {
-	const fontsPath = `${defaultSettings.publicFolder}/${defaultSettings.fontsSubfolder}`;
+const updateGitignore = async (fontNames) => {
+	const fontEntries = fontNames.map(fontName => `${getFontPath(fontName)}/`);
+	await addFilesToGitignore(fontEntries, 'Downloaded fonts');
+};
+
+// If a site has a branded font that is outside of this API - we should add it to /public/fonts/branded/{fontName}/*
+export default async function(config) {
+	// Download fonts from config.fontsToDownload or will default to ['roboto']
+	const fontNames = config?.fontsToDownload?.length > 0 ? config.fontsToDownload : ['roboto'];
+
+	const fontsPath = getFontPath();
 	if (!fs.existsSync(fontsPath)) {
 		fs.mkdirSync(fontsPath, { recursive: true });
 	}
 
-	// Download all font files
-	const fontPromises = fontFiles.map(fontPath => {
-		return streamFontToDestination(defaultSettings, fontPath);
-	});
-
-	return Promise.all(fontPromises).then(async () => {
-		// Update .gitignore after fonts are downloaded
-		await updateGitignore();
-	});
-}
+	await Promise.all(fontNames.map(downloadFont));
+	await updateGitignore(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();
+	await grabGlobalFonts(config);
 	await grabB2BData(config);
 	await grabCdn(config);
 	await getDefaultTradeQuestions(config);