@liiift-studio/sanity-font-manager 2.4.0 → 2.5.1

package/src/utils/generateFontData.js

@@ -1,35 +1,30 @@
-// Extracts metadata, metrics, glyph count, OpenType features, and variable axes from a TTF and optionally patches the Sanity font document
-
-import { Buffer } from 'buffer';
-import * as fontkit from 'fontkit';
+// Extracts metadata, metrics, glyph count, OpenType features, and variable axes from a font and optionally patches the Sanity font document
+
+import { parseFont } from './parseFont';
+import {
+	getFontMetadata,
+	getFontMetrics,
+	getVariationAxes,
+	getNamedInstances,
+	getAllFeatureTags,
+	getGlyphCount,
+	getCharacterSet,
+	getNameString,
+} from './fontHelpers';
 
 /**
- * Extracts metadata and metrics from a fontkit font object into plain objects.
- * @param {Object} font - fontkit font instance
+ * Extracts metadata and metrics from a lib-font parsed font into plain objects.
+ * Uses fontHelpers for all table access — no direct font.opentype.tables usage here.
+ * @param {object} font - lib-font Font instance
  * @returns {{ metaData: Object, metrics: Object }}
  */
 export function buildFontMetadata(font) {
-	const metaData = {
-		postscriptName: font.postscriptName,
-		fullName: font.fullName,
-		familyName: font.familyName,
-		subfamilyName: font.subfamilyName,
-		copyright: font.copyright,
-		version: font.version ? String(font.version).replaceAll('Version ', '') : '',
-		genDate: new Date().toISOString(),
-	};
-	const metrics = {
-		unitsPerEm: font.unitsPerEm,
-		ascender: font.ascent,
-		descender: font.descent,
-		lineGap: font.lineGap,
-		underlinePosition: font.underlinePosition,
-		underlineThickness: font.underlineThickness,
-		italicAngle: font.italicAngle,
-		capHeight: font.capHeight,
-		xHeight: font.xHeight,
-		boundingBox: font.bbox,
-	};
+	const metaData = getFontMetadata(font);
+	// Strip "Version " prefix for consistency with existing Sanity documents
+	if (metaData.version) {
+		metaData.version = String(metaData.version).replaceAll('Version ', '');
+	}
+	const metrics = getFontMetrics(font);
 	return { metaData, metrics };
 }
 
@@ -37,12 +32,11 @@ export default async function generateFontData({ fileInput, url, fontKit, fontId
 	if (fontId.startsWith('drafts.')) {
 		fontId = fontId.replace('drafts.', '');
 	}
-	console.log('generate-font-data ', fontId, commit);
+	console.log('Generate font data:', fontId, commit);
 
 	let srcUrl;
 	if (!url || url == null) {
 		srcUrl = await client.fetch(`*[_id == $id]{url}`, { id: fileInput.ttf.asset._ref });
-		console.log('src url ', srcUrl);
 		srcUrl = srcUrl[0].url;
 	} else {
 		srcUrl = url;
@@ -52,82 +46,41 @@ export default async function generateFontData({ fileInput, url, fontKit, fontId
 	if (!fontKit || fontKit == null) {
 		let buffer = await fetch(srcUrl);
 		buffer = await buffer.arrayBuffer();
-		buffer = Buffer.from(buffer);
-		font = fontkit.create(buffer);
+		font = await parseFont(buffer, `${fontId}.ttf`);
 	}
 
+	const variableAxes = getVariationAxes(font);
+	const namedInstances = getNamedInstances(font);
 
-	let variableAxes;
-	try {
-		variableAxes = font.variationAxes;
-	} catch (err) {
-		console.error('err: ', err);
-	}
-
-	let variableInstances;
-	try {
-		variableInstances = font.namedVariations;
-	} catch (e) {
-		console.log('variable instances 2 error : ', e.message);
-		let fvar = font?.fvar?.instance;
-
-		fvar?.forEach(fv => {
-			if (fv?.nameID === 2) fv.name = font?._tables?.name?.records?.fontSubfamily
-			if (fv?.nameID === 17) fv.name = font?._tables?.name?.records?.preferredSubfamily
-		})
-
+	// Build variableInstances as a keyed object matching existing Sanity document shape
+	let variableInstances = null;
+	if (namedInstances.length > 0 && variableAxes) {
 		variableInstances = {};
-		fvar.forEach(v => {
-			let key = v.name;
-			if (typeof key === 'object') {
-				key = Object.values(key)[0];
-			}
-
-			let coordKeys = Object.keys(variableAxes);
-			let coord = {};
-
-			coordKeys.forEach((ck, ckIndex) => {
-				coord[ck] = v.coord[ckIndex];
+		const axisTags = Object.keys(variableAxes);
+		for (const inst of namedInstances) {
+			const key = inst.name || inst.postScriptName || 'Unknown';
+			const coord = {};
+			axisTags.forEach((tag, index) => {
+				coord[tag] = inst.coordinates[index];
 			});
 			variableInstances[key] = coord;
-		});
-
+		}
 	}
-	console.log('font : ', font);
-	console.log('variable instances : ', variableInstances);
-	console.log('variable axes : ', variableAxes);
 
-	let opentypeFeatures = font.availableFeatures;
-	let glyphCount = font.numGlyphs;
-	let characterSet = font.characterSet;
+	console.log('Variable instances:', variableInstances);
+	console.log('Variable axes:', variableAxes);
 
-	let metaData = {
-		postscriptName: font.postscriptName,
-		fullName: font.fullName,
-		familyName: font.familyName,
-		subfamilyName: font.subfamilyName,
-		copyright: font.copyright,
-		version: font.version.replaceAll("Version ", ""),
-		genDate: new Date().toISOString(),
-	};
+	const opentypeFeatures = getAllFeatureTags(font);
+	const glyphCount = getGlyphCount(font);
+	const characterSet = getCharacterSet(font);
 
-	let metrics = {
-		unitsPerEm: font.unitsPerEm,
-		ascender: font.ascent,
-		descender: font.descent,
-		lineGap: font.lineGap,
-		underlinePosition: font.underlinePosition,
-		underlineThickness: font.underlineThickness,
-		italicAngle: font.italicAngle,
-		capHeight: font.capHeight,
-		xHeight: font.xHeight,
-		boundingBox: font.bbox
-	};
+	const { metaData, metrics } = buildFontMetadata(font);
 
 	let variableFont = false;
-	if (variableAxes && variableAxes != null && Object.keys(variableAxes).length > 0 && variableInstances && variableInstances != null && Object.keys(variableInstances).length > 0) {
+	if (variableAxes && variableInstances && Object.keys(variableInstances).length > 0) {
 		variableFont = true;
 	}
+
 	let patch = {
 		metrics: metrics,
 		metaData: metaData,
@@ -136,10 +89,10 @@ export default async function generateFontData({ fileInput, url, fontKit, fontId
 		variableInstances: JSON.stringify(variableInstances),
 		glyphCount: glyphCount,
 		opentypeFeatures: { chars: opentypeFeatures },
-		characterSet: { chars: characterSet }
-	}
+		characterSet: { chars: characterSet },
+	};
 
-	console.log('data : ', patch);
+	console.log('Font data patch:', Object.keys(patch));
 	if (commit) patch = await client.patch(fontId).set(patch).commit({ autoGenerateArrayKeys: true });
 	return patch;
 }

package/src/utils/getEmptyFontKit.js

@@ -1,5 +1,7 @@
-// Returns a zeroed-out fontkit-shaped placeholder object used when no font binary is available
-import * as fontkit from 'fontkit';
+// Parses font files and returns name/subfamily metadata groupings without writing to Sanity
+
+import { parseFont } from './parseFont';
+import { getNameString, getVariationAxes } from './fontHelpers';
 import slugify from 'slugify';
 
 /** Reads font files and returns name/subfamily metadata without writing to Sanity */
@@ -12,14 +14,16 @@ export async function getEmptyFontKit({ title, files, weightKeywordList, italicK
 
 		const file = files[i];
 		const fontBuffer = await readFontFile(file);
-		const font = fontkit.create(fontBuffer);
+		const font = await parseFont(fontBuffer, file.name);
 
-		let weightName = font?.name?.records?.preferredSubfamily ? font?.name?.records?.preferredSubfamily : font?.name?.records?.fontSubfamily;
-		weightName = weightName?.en ? weightName.en : weightName.constructor == Object ? weightName[Object.keys(weightName)[0]] : weightName;
+		let weightName = getNameString(font, 17) || getNameString(font, 2) || '';
 
-		let variableFont = font?.variationAxes && Object.keys(font.variationAxes).length > 0 ? true : false;
-		let subfamilyName = font.familyName.toLowerCase().trim().replace(title.toLowerCase().trim(), '').trim();
-		let fontTitle = font?.fullName.toLowerCase().trim();
+		const axes = getVariationAxes(font);
+		let variableFont = axes !== null;
+		const familyName = getNameString(font, 1);
+		const fullName = getNameString(font, 4);
+		let subfamilyName = familyName.toLowerCase().trim().replace(title.toLowerCase().trim(), '').trim();
+		let fontTitle = fullName.toLowerCase().trim();
 
 		weightKeywordList.forEach(keyword => {
 			const kw = keyword.toLowerCase().trim();
@@ -65,32 +69,30 @@ export async function getEmptyFontKit({ title, files, weightKeywordList, italicK
 		if (!fontNames[id]) {
 			fontNames[id] = [{
 				file: file.name,
-				fullName: font.fullName,
-				familyName: font.familyName,
+				fullName: fullName,
+				familyName: familyName,
 				subFamily: subfamilyName,
 			}];
 		} else if (fontNames[id].indexOf(file.name) == -1) {
 			fontNames[id].push({
 				file: file.name,
-				fullName: font.fullName,
-				familyName: font.familyName,
+				fullName: fullName,
+				familyName: familyName,
 				subFamily: subfamilyName,
 			})
 		}
-
-
 	}
 
-	console.log('font names : ', fontNames);
+	console.log('Font names:', fontNames);
 }
 
-/** Reads a font file and returns its content as a Uint8Array */
+/** Reads a font file and returns its content as an ArrayBuffer */
 const readFontFile = (file) => {
 	return new Promise((resolve, reject) => {
 		const reader = new FileReader();
 
 		reader.onload = (event) => {
-			resolve(new Uint8Array(event.target.result));
+			resolve(event.target.result);
 		};
 
 		reader.onerror = (error) => { reject(error); };

package/src/utils/parseFont.js

@@ -0,0 +1,55 @@
+// Async font parser — wraps lib-font event model in a Promise with decompressor bootstrap
+
+import pako from 'pako';
+
+// Set decompressor globals BEFORE lib-font is imported.
+// lib-font reads globalThis.pako and globalThis.unbrotli at module evaluation time
+// (top of woff.js / woff2.js), not at parse time. These must be set before lib-font
+// is first evaluated, so we use dynamic import() below to guarantee ordering.
+globalThis.pako = pako;
+
+// unbrotli is a UMD that sets globalThis.unbrotli as a side effect on evaluation.
+// We vendor it from lib-font/lib/unbrotli.js because the subpath is not in
+// lib-font's exports map (ERR_PACKAGE_PATH_NOT_EXPORTED).
+import '../vendor/unbrotli.js';
+
+// Lazy-loaded lib-font Font constructor — resolved on first parseFont() call.
+// Using dynamic import() guarantees globalThis.pako and globalThis.unbrotli are
+// set before lib-font evaluates, which static imports cannot guarantee in ESM.
+let _Font = null;
+
+/** Returns the lib-font Font constructor, loading it on first call */
+async function getFont() {
+	if (!_Font) {
+		const mod = await import('lib-font');
+		_Font = mod.Font;
+	}
+	return _Font;
+}
+
+/** Maximum font file size accepted for parsing (50 MB) */
+const MAX_FONT_FILE_SIZE = 50 * 1024 * 1024;
+
+/**
+ * Parse a font file from an ArrayBuffer.
+ * Returns a lib-font Font object with all tables accessible via font.opentype.tables.*.
+ *
+ * @param {ArrayBuffer} buffer - Raw font file bytes
+ * @param {string} filename - Original filename (used for format detection by lib-font)
+ * @returns {Promise<import('lib-font').Font>} Parsed lib-font Font object
+ * @throws {Error} If the file exceeds MAX_FONT_FILE_SIZE or parsing fails
+ */
+export async function parseFont(buffer, filename) {
+	if (buffer.byteLength > MAX_FONT_FILE_SIZE) {
+		throw new Error(`Font file exceeds ${MAX_FONT_FILE_SIZE / 1024 / 1024}MB limit: ${filename} (${(buffer.byteLength / 1024 / 1024).toFixed(1)}MB)`);
+	}
+
+	const Font = await getFont();
+
+	return new Promise((resolve, reject) => {
+		const font = new Font('font', { skipStyleSheet: true });
+		font.onload = (evt) => resolve(evt.detail.font);
+		font.onerror = (evt) => reject(new Error(evt.detail?.message || `Failed to parse ${filename}`));
+		font.fromDataBuffer(buffer, filename);
+	});
+}