@liiift-studio/sanity-font-manager 2.2.0

package/src/hooks/useSanityClient.js

@@ -0,0 +1,9 @@
+// Returns the Sanity client instance from the studio context
+import {useMemo} from 'react'
+import {useClient} from 'sanity'
+
+/** Returns a memoized Sanity client pinned to api version 2021-10-23 */
+export function useSanityClient() {
+	const client = useClient({apiVersion: '2021-10-23'})
+	return useMemo(() => client, [client])
+}

package/src/index.js

@@ -0,0 +1,56 @@
+// Entry point for @liiift-studio/sanity-font-manager — exports all font manager components, hooks, and utilities
+
+// Components
+export { BatchUploadFonts } from './components/BatchUploadFonts.jsx';
+export { GenerateCollectionsPairsComponent } from './components/GenerateCollectionsPairsComponent.jsx';
+export { UpdateScriptsComponent } from './components/UpdateScriptsComponent.jsx';
+export { SingleUploaderTool } from './components/SingleUploaderTool.jsx';
+export { RegenerateSubfamiliesComponent } from './components/RegenerateSubfamiliesComponent.jsx';
+export { UploadScriptsComponent } from './components/UploadScriptsComponent.jsx';
+export { FontScriptUploaderComponent } from './components/FontScriptUploaderComponent.jsx';
+export { default as StatusDisplay } from './components/StatusDisplay.jsx';
+export { default as PriceInput } from './components/PriceInput.jsx';
+export { default as UploadButton } from './components/UploadButton.jsx';
+
+// Hooks
+export { useSanityClient } from './hooks/useSanityClient.js';
+
+// Core utilities
+export { default as generateCssFile } from './utils/generateCssFile.js';
+export { default as generateFontData } from './utils/generateFontData.js';
+export { default as generateFontFile } from './utils/generateFontFile.js';
+export { default as generateSubset } from './utils/generateSubset.js';
+export { default as parseVariableFontInstances } from './utils/parseVariableFontInstances.js';
+export { getEmptyFontKit } from './utils/getEmptyFontKit.js';
+export { SCRIPTS, SCRIPTS_OBJECT, HtmlDescription } from './utils/utils.js';
+
+// Font processing utilities
+export {
+	processFontFiles,
+	readFontFile,
+	extractFontMetadata,
+	extractWeightName,
+	extractWeightFromFullName,
+	processSubfamilyName,
+	processItalicKeywords,
+	formatFontTitle,
+	addItalicToFontTitle,
+	createFontObject,
+	determineWeight,
+	sortFontObjects,
+	logFontInfo,
+} from './utils/processFontFiles.js';
+
+export { uploadFontFiles } from './utils/uploadFontFiles.js';
+export { updateTypefaceDocument } from './utils/updateTypefaceDocument.js';
+export { renameFontDocuments } from './utils/regenerateFontData.js';
+export { updateFontPrices } from './utils/updateFontPrices.js';
+export { sanitizeForSanityId } from './utils/sanitizeForSanityId.js';
+
+// Keyword utilities
+export {
+	generateStyleKeywords,
+	reverseSpellingLookup,
+	expandAbbreviations,
+	removeWeightNames,
+} from './utils/generateKeywords.js';

package/src/utils/generateCssFile.js

@@ -0,0 +1,197 @@
+// Builds a @font-face CSS file from a WOFF2 blob — URL or base64 src, variable font axis descriptors, metric-tuned fallback @font-face for CLS reduction
+import base64 from 'base-64';
+import { Buffer } from 'buffer';
+import * as fontkit from 'fontkit';
+
+function _arrayBufferToBase64(buffer) {
+	var binary = '';
+	var bytes = new Uint8Array(buffer);
+	var len = bytes.byteLength;
+	for (var i = 0; i < len; i++) {
+		binary += String.fromCharCode(bytes[i]);
+	}
+	return base64.encode(binary);
+}
+
+/**
+ * Reads variable axes from a fontkit font object and returns:
+ *   { descriptors, skipped }
+ * where `descriptors` is the CSS string for the @font-face block and
+ * `skipped` lists axis tags that have no CSS descriptor (opsz, custom axes, etc.)
+ * so callers can surface them in comments.
+ *
+ * Edge cases handled:
+ *  - Degenerate axes (min === max): skipped — no actual variation range
+ *  - ital with max === 0: skipped — axis exists but font has no italic
+ *  - slnt ordering: sorted ascending as CSS spec requires
+ *  - ital + slnt coexistence: slnt takes priority (more expressive)
+ *  - min > max from corrupt font data: clamped with Math.min/Math.max
+ * @param {Object} font - fontkit font instance
+ * @returns {{ descriptors: string, skipped: string[] }}
+ */
+export function buildVFDescriptors(font) {
+	const cssAxes = {}
+	const skipped = []
+	try {
+		const va = font.variationAxes
+		if (!va) return { descriptors: '', skipped: [] }
+
+		for (const [tag, axis] of Object.entries(va)) {
+			const lo = Math.min(axis.min, axis.max)
+			const hi = Math.max(axis.min, axis.max)
+
+			// Skip degenerate axes — no actual range
+			if (lo === hi) { skipped.push(tag); continue }
+
+			if (tag === 'wght') {
+				cssAxes['font-weight'] = `${lo} ${hi}`
+			} else if (tag === 'wdth') {
+				cssAxes['font-stretch'] = `${lo}% ${hi}%`
+			} else if (tag === 'slnt') {
+				// slnt: ascending order required by CSS Fonts Level 4
+				cssAxes['font-style'] = `oblique ${lo}deg ${hi}deg`
+			} else if (tag === 'ital' && !cssAxes['font-style']) {
+				// ital: only emit if font actually has italic range; slnt takes priority
+				if (hi > 0) cssAxes['font-style'] = 'italic'
+				else skipped.push(tag)
+			} else {
+				// opsz, GRAD, XTRA, XHGT and all other custom axes have no CSS @font-face descriptor
+				skipped.push(tag)
+			}
+		}
+	} catch (_) {
+		// axes unreadable — no descriptors
+	}
+	const descriptors = Object.entries(cssAxes).map(([k, v]) => `${k}:${v}`).join(';') + (Object.keys(cssAxes).length ? ';' : '')
+	return { descriptors, skipped }
+}
+
+// Cross-platform fallback font stacks by category.
+// Multiple local() sources ensure the first available system font is used.
+// Liberation Sans covers Linux; Roboto covers Android; Georgia is universal for serifs.
+const FALLBACK_STACKS = {
+	'sans-serif': "local('Arial'), local('Helvetica Neue'), local('Roboto'), local('Liberation Sans')",
+	'serif':      "local('Georgia'), local('Times New Roman'), local('Times')",
+	'monospace':  "local('Courier New'), local('Courier'), local('Menlo'), local('Monaco')",
+	// Display and script fonts have no universally suitable system fallback; default to sans-serif
+	'default':    "local('Arial'), local('Helvetica Neue'), local('Roboto'), local('Liberation Sans')",
+};
+
+// OS/2 sFamilyClass high byte → FALLBACK_STACKS key.
+// Classes 1–5,7 = serif variants; 8 = sans-serif; 9 = ornamental; 10 = script; 12 = symbolic.
+const FAMILY_CLASS_MAP = {
+	1: 'serif', 2: 'serif', 3: 'serif', 4: 'serif', 5: 'serif', 7: 'serif',
+	8: 'sans-serif',
+};
+
+/** Detects font category from the OS/2 sFamilyClass field; returns a key into FALLBACK_STACKS */
+function detectFontCategory(font) {
+	try {
+		const familyClass = font._tables?.['OS/2']?.sFamilyClass ?? 0;
+		const highByte = (familyClass >> 8) & 0xFF;
+		return FAMILY_CLASS_MAP[highByte] ?? 'default';
+	} catch {
+		return 'default';
+	}
+}
+
+/** Extracts metric override percentages and detects the category fallback stack from a font ArrayBuffer */
+function calcFallbackData(arrayBuffer) {
+	try {
+		let font = fontkit.create(Buffer.from(arrayBuffer));
+		let upm = font.unitsPerEm;
+		let category = detectFontCategory(font);
+		return {
+			fallbackSrc: FALLBACK_STACKS[category],
+			ascentOverride: `${(font.ascent / upm * 100).toFixed(2)}%`,
+			descentOverride: `${(Math.abs(font.descent) / upm * 100).toFixed(2)}%`,
+			lineGapOverride: `${(font.lineGap / upm * 100).toFixed(2)}%`,
+		};
+	} catch (err) {
+		console.error('Failed to extract fallback font data:', err);
+		return {
+			fallbackSrc: FALLBACK_STACKS['default'],
+			ascentOverride: '100%',
+			descentOverride: '0%',
+			lineGapOverride: '0%',
+		};
+	}
+}
+
+export default async function generateCssFile({
+	woff2File,
+	fileInput,
+	language = null,
+	fileName,
+	fontName,
+	variableFont,
+	weight,
+	style = 'Normal',
+	client,
+}) {
+	try {
+		// Read the file once; reuse the same buffer for base64 encoding and fontkit analysis
+		let arrayBuffer = await woff2File.arrayBuffer();
+		let b64 = _arrayBufferToBase64(arrayBuffer);
+		let fontkitFont = fontkit.create(Buffer.from(arrayBuffer));
+		let { fallbackSrc, ascentOverride, descentOverride, lineGapOverride } = calcFallbackData(arrayBuffer);
+
+		let cssString;
+		if (variableFont) {
+			let { descriptors, skipped } = buildVFDescriptors(fontkitFont);
+			// Axes with no CSS @font-face descriptor (opsz needs font-optical-sizing:auto on elements;
+			// custom axes like GRAD require CSS @font-face syntax not yet standardised).
+			let skipComment = skipped.length
+				? `/* axes present but have no @font-face descriptor: ${skipped.join(', ')}` +
+				  (skipped.includes('opsz') ? ' — add font-optical-sizing:auto to your element CSS' : '') +
+				  ' */'
+				: ''
+			cssString = `${skipComment}@font-face{font-family:'${fontName}';src:url(data:application/font-woff2;charset=utf-8;base64,${b64})format('woff2-variations');${descriptors}font-display:swap;}`;
+		} else {
+			let fontStyle = style === 'Italic' ? 'italic' : 'normal';
+			cssString = `@font-face{font-family:'${fontName}';src:url(data:application/font-woff2;charset=utf-8;base64,${b64})format('woff2');font-weight:${weight};font-style:${fontStyle};font-display:swap;}`;
+		}
+
+		// Fallback @font-face: tunes a category-appropriate system font to match the custom font's
+		// line metrics (ascent/descent/lineGap), reducing layout shift while the custom font loads.
+		// Customers who reference fontSrc in their own projects get this fallback automatically.
+		let fallbackCssString = `@font-face{font-family:'${fontName} Fallback';src:${fallbackSrc};ascent-override:${ascentOverride};descent-override:${descentOverride};line-gap-override:${lineGapOverride};}`;
+
+		let uploadBuffer = Buffer.from(cssString + fallbackCssString, 'utf-8');
+		let doc = await client.assets.upload('file', uploadBuffer, { filename: fileName + '.css' });
+
+		let newFileInput = language == null ?
+			{
+				...fileInput,
+				css: {
+					_type: 'file',
+					asset: {
+						_type: 'reference',
+						_ref: doc._id
+					}
+				}
+			}
+			:
+			{
+				...fileInput,
+				[language]: {
+					...fileInput[language],
+					css: {
+						_type: 'file',
+						asset: {
+							_type: 'reference',
+							_ref: doc._id
+						}
+					}
+				}
+			}
+
+		return newFileInput;
+
+	}
+	catch (err) {
+		console.error(err);
+		throw err;
+	}
+
+}

package/src/utils/generateFontData.js

@@ -0,0 +1,145 @@
+// 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 and metrics from a fontkit font object into plain objects.
+ * @param {Object} font - fontkit 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,
+	};
+	return { metaData, metrics };
+}
+
+export default async function generateFontData({ fileInput, url, fontKit, fontId, client, commit = true }) {
+	if (fontId.startsWith('drafts.')) {
+		fontId = fontId.replace('drafts.', '');
+	}
+	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;
+	}
+
+	let font = fontKit;
+	if (!fontKit || fontKit == null) {
+		let buffer = await fetch(srcUrl);
+		buffer = await buffer.arrayBuffer();
+		buffer = Buffer.from(buffer);
+		font = fontkit.create(buffer);
+	}
+
+
+	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
+		})
+
+		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];
+			});
+			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;
+
+	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(),
+	};
+
+	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
+	};
+
+	let variableFont = false;
+	if (variableAxes && variableAxes != null && Object.keys(variableAxes).length > 0 && variableInstances && variableInstances != null && Object.keys(variableInstances).length > 0) {
+		variableFont = true;
+	}
+	let patch = {
+		metrics: metrics,
+		metaData: metaData,
+		variableFont: variableFont,
+		variableAxes: JSON.stringify(variableAxes),
+		variableInstances: JSON.stringify(variableInstances),
+		glyphCount: glyphCount,
+		opentypeFeatures: { chars: opentypeFeatures },
+		characterSet: { chars: characterSet }
+	}
+
+	console.log('data : ', patch);
+	if (commit) patch = await client.patch(fontId).set(patch).commit({ autoGenerateArrayKeys: true });
+	return patch;
+}

package/src/utils/generateFontFile.js

@@ -0,0 +1,38 @@
+// Triggers server-side font format conversion via the consuming site's fontWorker API endpoint
+
+export default async function generateFontFile({
+	srcUrl,
+	language = null,
+	filename,
+	codes,
+	documentId,
+	documentTitle,
+	documentVariableFont,
+	documentStyle,
+	documentWeight,
+	fileInput
+}) {
+	await fetch(`${process.env.SANITY_STUDIO_SITE_URL}/api/sanity/fontWorker`, {
+		method: 'POST',
+		mode: 'no-cors',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({
+			code: 'generate-fonts',
+			language: language,
+			srcUrl: srcUrl,
+			filename: filename,
+			documentId: documentId,
+			documentTitle: documentTitle,
+			documentVariableFont: documentVariableFont,
+			documentStyle: documentStyle,
+			documentWeight: documentWeight,
+			fileInput: fileInput,
+			codes: codes
+		})
+	}).catch(e => {
+		console.error(e.message);
+		return -1;
+	});
+	return 1;
+
+}

package/src/utils/generateKeywords.js

@@ -0,0 +1,185 @@
+// Builds weight and italic keyword lists with abbreviation expansions for parsing font subfamily names
+
+const coreWeights = ["Hairline", "ExtraThin", "Thin", "Mager", "Maigre", "ExtraLight", "Light", "Chiaro", "Lite", "Leicht", "Demi", "Book", "Buch", "Regular", "Normal", "Medium", "Stark", "Thick", "Kräftig", "Viertelfett", "Halbfett", "Dreiviertelfett", "Dark", "Bold", "Neretto", "Gras", "Fett", "Extrafett", "Black", "Nero", "Heavy", "Nerissimo", "Ultra", "Fat", "Poster"];
+const modifiers = ["Demi", "Semi", "Extra", "Ultra", "Super", "Plus"];
+
+const coreItalics = ["Italic", "Slant", "Oblique", "Cursive", "Rotalic", "Reverse", "Crab Claw", "Crabclaw", "South Paw", "Southpaw", "Backwards", "Backslant", "Backslanted", "Back Slant"];
+
+/** All known abbreviation-to-canonical-name mappings, sorted alphabetically */
+const alternativeSpelling = {
+	Backslant: ["Bsl"],
+	Backwards: ["Bck"],
+	Black: ["Blak", "Blk"],
+	Bold: ["Bd", "Bld"], // B omitted — too ambiguous
+	Condensed: ["Cond", "Cnd"],
+	Crabclaw: ["Crab", "Claw"],
+	Cursive: ["Cur"],
+	Dark: ["Drk"],
+	Expanded: ["Exp"],
+	Extra: ["Xt", "Xtra", "Xtr", "X"], // X omitted as standalone — too ambiguous
+	ExtraBlack: ["Xblk", "XBlk", "Xblck", "XBlck"],
+	ExtraBold: ["Xbd", "XBd", "Xbld", "XBld", "Xbold", "XBold", "ExBold", "Exbold", "Exbd", "ExBd", "Exbld", "ExBld"],
+	ExtraCondensed: ["XCond", "Xcnd"],
+	ExtraExpanded: ["XExp"],
+	ExtraLight: ["Xlight", "XLight", "Xlt", "XLt", "Xlgt", "XLgt", "Xl", "XL", "Xlght", "XLght"],
+	ExtraThin: ["Xthin", "Xthn", "Xth", "XThin", "XThn", "XTh", "XT"],
+	Extended: ["Ext"],
+	Hairline: ["Hl", "Hln", "Hlnn", "Hlnne", "Hlnnne"],
+	Italic: ["Ital", "It"],
+	Light: ["Lt", "Lght"],
+	Medium: ["Med", "Md", "md", "med"],
+	Oblique: ["Obl"],
+	Plus: ["Pls"],
+	Regular: ["Reg", "Rg"],
+	Reverse: ["Rev"],
+	Rotalic: ["Rot"],
+	SemiBold: ["SmBd", "Sb", "Sbd", "Sbld", "Sbold", "Semibd", "SemiBd", "Semibld", "SemiBld", "semiBd", "semiBld"],
+	Slant: ["Sl"],
+	Southpaw: ["South", "Paw"],
+	Super: ["Supr"],
+	Thin: ["Thn"],
+	Ultra: ["Ult", "Ultre", "Ul", "Ulta"],
+	XX: ["XXt", "XXtra", "XXtr", "XX"],
+	XXBlack: ["XXblk", "XXBlk", "XXblck", "XXBlck"],
+	XXLight: ["XXlight", "XXLight", "XXlt", "XXLt", "XXlgt", "XXLgt", "XXl", "XXL", "XXlght", "XXLght"],
+	XXX: ["XXXt", "XXXtra", "XXXtr", "XXX"],
+	XXXLight: ["XXXlight", "XXXLight", "XXXlt", "XXXLt", "XXXlgt", "XXXLgt", "XXXl", "XXXL", "XXXlght", "XXXLght"],
+};
+
+/** Maps an abbreviated font name word back to its canonical weight/style name */
+export function reverseSpellingLookup(str) {
+	// Exact match first to avoid partial collisions
+	let exactMatch = "";
+	Object.keys(alternativeSpelling).forEach(function (key) {
+		alternativeSpelling[key].forEach(function (alternative) {
+			if (str === alternative) {
+				exactMatch = key;
+			}
+		});
+	});
+	if (exactMatch) return exactMatch;
+
+	// Fall back to longest word-boundary match
+	let result = "";
+	let longestMatch = 0;
+	Object.keys(alternativeSpelling).forEach(function (key) {
+		alternativeSpelling[key].forEach(function (alternative) {
+			const regex = new RegExp(`\\b${alternative}\\b`);
+			if (regex.test(str) && alternative.length > longestMatch) {
+				result = key;
+				longestMatch = alternative.length;
+			}
+		});
+	});
+	return result;
+}
+
+/** Expands each word in a string from abbreviation to its canonical weight/style name */
+export function expandAbbreviations(str) {
+	if (!str) return str;
+	return str.split(' ')
+		.map(word => {
+			const expanded = reverseSpellingLookup(word);
+			return expanded || word;
+		})
+		.join(' ');
+}
+
+/** Removes weight and style keywords from a string, returning only the remainder */
+export function removeWeightNames(str) {
+	if (!str) return str;
+	return str.split(' ')
+		.map(word => {
+			coreWeights.forEach((weight) => {
+				if (word === weight) word = "";
+				modifiers.forEach((modifier) => {
+					if (word === modifier || modifier + weight === word) word = "";
+				});
+			});
+			const expanded = reverseSpellingLookup(word);
+			if (expanded) return "";
+			return word;
+		})
+		.join(' ')
+		.trim();
+}
+
+/** Generates comprehensive weight and italic keyword lists including all alternative spellings */
+export function generateStyleKeywords() {
+	let weightKeywordList = [];
+	let italicKeywordList = [];
+
+	// Start with all core weights
+	weightKeywordList = [...coreWeights];
+
+	// Add all modifier + weight combinations
+	modifiers.forEach(modifier => {
+		coreWeights.forEach(weight => {
+			weightKeywordList.push(modifier + weight);
+		});
+	});
+
+	// Add standalone modifiers
+	weightKeywordList = [...weightKeywordList, ...modifiers];
+
+	// Set up italic keywords
+	italicKeywordList = [...coreItalics];
+
+	// Expand weight list with alternative spellings
+	weightKeywordList = weightKeywordList.map(function (el) {
+		var newEls = [];
+		Object.keys(alternativeSpelling).forEach(function (key) {
+			if (el.indexOf(key) !== -1) {
+				alternativeSpelling[key].forEach(function (alternative) {
+					let newSpelling = el.replace(key, alternative);
+					newEls.push(newSpelling);
+					Object.keys(alternativeSpelling).forEach(function (key2) {
+						if (newSpelling.indexOf(key2) !== -1) {
+							alternativeSpelling[key2].forEach(function (alternative2) {
+								let newSpelling2 = newSpelling.replace(key2, alternative2);
+								newEls.push(newSpelling2);
+								Object.keys(alternativeSpelling).forEach(function (key3) {
+									if (newSpelling2.indexOf(key3) !== -1) {
+										alternativeSpelling[key3].forEach(function (alternative3) {
+											newEls.push(newSpelling2.replace(key3, alternative3));
+										});
+									}
+								});
+							});
+						}
+					});
+				});
+			}
+		});
+		newEls.push(el);
+		return newEls;
+	}).reduce(function (a, b) {
+		return a.concat(b);
+	});
+
+	// Expand italic list with alternative spellings
+	italicKeywordList = italicKeywordList.map(function (el) {
+		var newEls = [];
+		Object.keys(alternativeSpelling).forEach(function (key) {
+			if (el.indexOf(key) !== -1) {
+				alternativeSpelling[key].forEach(function (alternative) {
+					newEls.push(el.replace(key, alternative));
+				});
+			}
+		});
+		newEls.push(el);
+		return newEls;
+	}).reduce(function (a, b) {
+		return a.concat(b);
+	});
+
+	// Sort longest to shortest so more specific matches win
+	weightKeywordList = weightKeywordList.sort((a, b) => b.length - a.length);
+	italicKeywordList = italicKeywordList.sort((a, b) => b.length - a.length);
+
+	// Deduplicate
+	weightKeywordList = weightKeywordList.filter((item, pos) => weightKeywordList.indexOf(item) === pos);
+	italicKeywordList = italicKeywordList.filter((item, pos) => italicKeywordList.indexOf(item) === pos);
+
+	return { weightKeywordList, italicKeywordList };
+}

package/src/utils/generateSubset.js

@@ -0,0 +1,45 @@
+// Requests DS-WEB fingerprinted WOFF2 and display subset generation from an existing WOFF2 via fontWorker
+// The server subsets the WOFF2 directly — no TTF conversion involved.
+
+/**
+ * Calls fontWorker to generate a display subset WOFF2 and subset CSS from an existing WOFF2 URL.
+ * Patches fileInput.woff2_subset and fileInput.css_subset on the Sanity document directly.
+ * @param {object} params
+ * @param {string} params.woff2Url - CDN URL of the existing WOFF2 to subset
+ * @param {string} params.filename - base filename (no extension) for the generated assets
+ * @param {string} params.documentId
+ * @param {string} params.documentTitle
+ * @param {boolean} params.documentVariableFont
+ * @param {string} params.documentStyle
+ * @param {string} params.documentWeight
+ * @returns {Promise<number>} 1 on success, -1 on network error
+ */
+export default async function generateSubset({
+	woff2Url,
+	filename,
+	documentId,
+	documentTitle,
+	documentVariableFont,
+	documentStyle,
+	documentWeight,
+}) {
+	await fetch(`${process.env.SANITY_STUDIO_SITE_URL}/api/sanity/fontWorker`, {
+		method: 'POST',
+		mode: 'no-cors',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({
+			code: 'generate-subset',
+			woff2Url,
+			filename,
+			documentId,
+			documentTitle,
+			documentVariableFont,
+			documentStyle,
+			documentWeight,
+		})
+	}).catch(e => {
+		console.warn('Subset generation call failed:', e.message);
+		return -1;
+	});
+	return 1;
+}