@liiift-studio/sanity-font-manager 2.5.0 → 2.5.2

package/src/utils/parseVariableFontInstances.js

@@ -1,21 +1,201 @@
-// Resolves named variable font instances into Sanity font document references, creating documents for missing instances
+// Resolves named variable font instances into Sanity font document references with multi-pass subfamily-aware matching
 
 import { nanoid } from 'nanoid';
 import { expandAbbreviations } from './generateKeywords';
 
+/** Known width prefixes — longest first to match XXNarrow before Narrow */
+const WIDTH_PREFIXES = [
+	'XXXWide', 'XXWide', 'XWide', 'Wide',
+	'XXXNarrow', 'XXNarrow', 'XNarrow', 'Narrow',
+];
+
 /**
- * Parses a variable font's named instances and maps each to its corresponding static font document.
- * Uses 6 matching strategies in priority order:
- *   1. Exact title match
- *   2. Title normalisation (strips VF/var/variable prefixes, handles Regular/Italic suffixes)
- *   3. Abbreviation expansion
- *   4. Weight + style matching
- *   5. weightName comparison
- *   6. metaData.fullName fallback
+ * Parses a VF instance name into subfamily (width), weight, and style components.
+ * e.g. "XXNarrow Bold Slant" → { subfamily: "XXNarrow", weight: "Bold", style: "Slant" }
+ */
+function parseInstanceName(instanceName) {
+	let subfamily = '';
+	let remaining = instanceName.trim();
+
+	for (const prefix of WIDTH_PREFIXES) {
+		if (remaining.toLowerCase().startsWith(prefix.toLowerCase() + ' ') || remaining.toLowerCase() === prefix.toLowerCase()) {
+			subfamily = prefix;
+			remaining = remaining.substring(prefix.length).trim();
+			break;
+		}
+	}
+
+	let style = '';
+	for (const suffix of ['Backslant', 'Slant', 'Italic', 'Oblique']) {
+		if (remaining.toLowerCase().endsWith(' ' + suffix.toLowerCase()) || remaining.toLowerCase() === suffix.toLowerCase()) {
+			style = suffix;
+			remaining = remaining.substring(0, remaining.length - suffix.length).trim();
+			break;
+		}
+	}
+
+	return { subfamily, weight: remaining || 'Regular', style };
+}
+
+/**
+ * Filters static fonts to the same subfamily, preventing cross-subfamily matches.
+ */
+function filterBySubfamily(staticFonts, instanceSubfamily, typefaceName) {
+	if (!instanceSubfamily) {
+		return staticFonts.filter(sf => {
+			const sub = (sf.subfamily || '').toLowerCase();
+			if (sub === '' || sub === 'regular') return true;
+			const afterTypeface = (sf.title || '').replace(typefaceName, '').trim();
+			return !WIDTH_PREFIXES.some(p => afterTypeface.toLowerCase().startsWith(p.toLowerCase()));
+		});
+	}
+	const lowerSf = instanceSubfamily.toLowerCase();
+	const expanded = (expandAbbreviations(instanceSubfamily) || '').toLowerCase();
+	return staticFonts.filter(sf => {
+		const sub = (sf.subfamily || '').toLowerCase();
+		if (sub === lowerSf || (expanded && sub === expanded)) return true;
+		const afterTypeface = (sf.title || '').replace(typefaceName, '').trim().toLowerCase();
+		if (afterTypeface.startsWith(lowerSf)) return true;
+		if (expanded && afterTypeface.startsWith(expanded)) return true;
+		return false;
+	});
+}
+
+/** Weight keyword → numeric weight mapping */
+const WEIGHT_MAP = [
+	{ term: 'ultra', weight: 950 },
+	{ term: 'xxlight', weight: 200 },
+	{ term: 'xlight', weight: 250 },
+	{ term: 'extralight', weight: 200 },
+	{ term: 'extra light', weight: 200 },
+	{ term: 'thin', weight: 100 },
+	{ term: 'hairline', weight: 100 },
+	{ term: 'light', weight: 300 },
+	{ term: 'regular', weight: 400 },
+	{ term: 'normal', weight: 400 },
+	{ term: 'medium', weight: 500 },
+	{ term: 'semibold', weight: 600 },
+	{ term: 'semi bold', weight: 600 },
+	{ term: 'extrabold', weight: 800 },
+	{ term: 'extra bold', weight: 800 },
+	{ term: 'xbold', weight: 800 },
+	{ term: 'bold', weight: 700 },
+	{ term: 'black', weight: 900 },
+	{ term: 'heavy', weight: 900 },
+];
+
+/** Converts a weight name to a numeric weight */
+function weightFromName(name) {
+	const lower = name.toLowerCase();
+	for (const { term, weight } of WEIGHT_MAP) {
+		if (lower === term || lower.includes(term)) return weight;
+	}
+	return 400;
+}
+
+/**
+ * Multi-pass matching strategies, ordered from most confident to least.
+ * Each returns a match function: (instanceName, parsed, candidates, typefaceName, font) => matchedFont|null
+ */
+const STRATEGIES = [
+	// Pass 1: Exact title match (with typeface prefix)
+	{
+		name: 'exact-title',
+		match: (instanceName, parsed, candidates, typefaceName) => {
+			const withPrefix = `${typefaceName} ${instanceName}`;
+			return candidates.find(sf => sf.title === instanceName || sf.title === withPrefix) || null;
+		},
+	},
+	// Pass 2: Title normalisation — strip typeface name and compare remainder
+	{
+		name: 'title-normalised',
+		match: (instanceName, parsed, candidates, typefaceName) => {
+			return candidates.find(sf => {
+				const sfName = (sf.title || '').replace(typefaceName, '').trim();
+				if (sfName.toLowerCase() === instanceName.toLowerCase()) return true;
+				// Handle "Regular" suffix: instance "Narrow Regular" → font title remainder "Narrow"
+				if (parsed.weight === 'Regular' && !parsed.style) {
+					if (sfName.toLowerCase() === parsed.subfamily.toLowerCase()) return true;
+				}
+				return false;
+			}) || null;
+		},
+	},
+	// Pass 3: Abbreviation expansion (XLight → ExtraLight, XBold → ExtraBold)
+	{
+		name: 'abbreviation',
+		match: (instanceName, parsed, candidates, typefaceName) => {
+			const expandedFull = instanceName.split(' ').map(w => expandAbbreviations(w) || w).join(' ');
+			let found = candidates.find(sf => {
+				const sfName = (sf.title || '').replace(typefaceName, '').trim();
+				return sfName.toLowerCase() === expandedFull.toLowerCase();
+			});
+			if (found) return found;
+
+			// Try expanding just the weight part and rebuilding
+			const expandedWeight = expandAbbreviations(parsed.weight) || parsed.weight;
+			const target = [parsed.subfamily, expandedWeight, parsed.style].filter(Boolean).join(' ');
+			return candidates.find(sf => {
+				const sfName = (sf.title || '').replace(typefaceName, '').trim();
+				return sfName.toLowerCase() === target.toLowerCase();
+			}) || null;
+		},
+	},
+	// Pass 4: fullName metadata comparison
+	{
+		name: 'metadata-fullName',
+		match: (instanceName, parsed, candidates, typefaceName) => {
+			return candidates.find(sf => {
+				if (!sf.metaData?.fullName) return false;
+				const typefacePattern = new RegExp(`^${typefaceName}\\s+`, 'i');
+				const stylePart = sf.metaData.fullName.replace(typefacePattern, '').trim();
+				return instanceName.toLowerCase() === stylePart.toLowerCase();
+			}) || null;
+		},
+	},
+	// Pass 5: Weight + style matching (numeric, within subfamily)
+	{
+		name: 'weight-style',
+		match: (instanceName, parsed, candidates) => {
+			const instanceWeight = weightFromName(parsed.weight);
+			const isBackslant = parsed.style.toLowerCase() === 'backslant';
+			const isSlant = parsed.style.toLowerCase() === 'slant';
+			const isItalic = parsed.style.toLowerCase() === 'italic';
+
+			return candidates.find(sf => {
+				if (Number(sf.weight) !== instanceWeight) return false;
+				if (isBackslant) return sf.style === 'Italic' && sf.title?.toLowerCase().includes('backslant');
+				if (isSlant) return sf.style === 'Italic' && !sf.title?.toLowerCase().includes('backslant');
+				if (isItalic) return sf.style === 'Italic';
+				return sf.style === 'Regular';
+			}) || null;
+		},
+	},
+	// Pass 6: weightName string comparison
+	{
+		name: 'weightName',
+		match: (instanceName, parsed, candidates) => {
+			const cleanInstance = parsed.weight.toLowerCase().trim();
+			return candidates.find(sf => {
+				if (!sf.weightName) return false;
+				const cleanWeight = sf.weightName.toLowerCase().replace(/italic|slant|backslant/gi, '').trim();
+				return cleanInstance === cleanWeight;
+			}) || null;
+		},
+	},
+];
+
+/**
+ * Multi-pass variable font instance matcher.
+ *
+ * For each strategy (most confident first):
+ *   1. Try to match ALL unmatched instances against ALL unclaimed fonts
+ *   2. Collect all matches for this pass
+ *   3. Claim matched fonts, remove from both pools
+ *   4. Move to next strategy with remaining unmatched
  *
- * @param {Object} font - The variable font object (must have typefaceName and variableInstances)
- * @param {Object} client - Sanity client (parameterized queries only)
- * @returns {Promise<Array>} Array of { key, value, _key } instance mappings
+ * This prevents a less-specific match from "stealing" a font that would be
+ * the exact match for a different instance processed later.
  */
 export const parseVariableFontInstances = async (font, client) => {
 	if (!font.variableFont || !font.variableInstances) return [];
@@ -30,19 +210,12 @@ export const parseVariableFontInstances = async (font, client) => {
 
 	if (Object.keys(variableInstances).length === 0) return [];
 
-	// Fetch the typeface's curated font list (parameterized — no injection risk)
+	// Fetch static fonts
 	let staticFonts;
 	const typeface = await client.fetch(
 		`*[_type == 'typeface' && title == $typefaceName][0]{
 			'fonts': styles.fonts[]-> {
-				_id,
-				title,
-				subfamily,
-				style,
-				weight,
-				weightName,
-				metaData,
-				variableFont
+				_id, title, subfamily, style, weight, weightName, metaData, variableFont
 			}
 		}`,
 		{ typefaceName: font.typefaceName }
@@ -55,154 +228,71 @@ export const parseVariableFontInstances = async (font, client) => {
 		console.warn('Typeface not found or no fonts in curated list, falling back to all fonts query');
 		staticFonts = await client.fetch(
 			`*[_type == 'font' && typefaceName == $typefaceName && variableFont != true]{
-				_id,
-				title,
-				subfamily,
-				style,
-				weight,
-				weightName,
-				metaData
+				_id, title, subfamily, style, weight, weightName, metaData
 			}`,
 			{ typefaceName: font.typefaceName }
 		);
 	}
 
-	console.log('Variable font instances:', Object.keys(variableInstances));
-	console.log('Available static fonts:', staticFonts.map(sf => sf.title));
+	const instanceNames = Object.keys(variableInstances);
+	console.log('Variable font instances:', instanceNames.length);
+	console.log('Available static fonts:', staticFonts.length);
 
-	const instanceMappings = [];
+	// Parse all instance names upfront
+	const parsedInstances = instanceNames.map(name => ({
+		name,
+		parsed: parseInstanceName(name),
+	}));
 
-	Object.keys(variableInstances).forEach(instanceName => {
-		let matchingFont = null;
+	// Track results and claimed fonts
+	const results = new Map(); // instanceName → { fontId, strategy }
+	const claimedFontIds = new Set();
 
-		// Strategy 1: Exact title match
-		matchingFont = staticFonts.find(sf => sf.title === instanceName);
+	// Multi-pass: each strategy gets a full pass over all remaining unmatched instances
+	for (const strategy of STRATEGIES) {
+		const unmatched = parsedInstances.filter(inst => !results.has(inst.name));
+		if (unmatched.length === 0) break;
 
-		// Strategy 2: Title normalisation — strip VF/var/variable prefix words, handle Regular/Italic
-		if (!matchingFont && staticFonts.some(sf => sf.metaData?.fullName)) {
-			matchingFont = staticFonts.find(sf => {
-				if (!sf.metaData?.fullName) return false;
-
-				let fullName = sf.metaData.fullName;
-
-				const WORDS_TO_REMOVE = ['VF', 'var', 'variable', 'VAR', 'vf'];
-				const variableName = font.metaData?.familyName
-					?.replace(new RegExp(`\\b(${WORDS_TO_REMOVE.join('|')})\\b`, 'gi'), '')
-					.replace(/\s{2,}/g, ' ')
-					.trim();
-
-				if (variableName && fullName.startsWith(variableName)) {
-					fullName = fullName.substring(variableName.length).trim();
-				}
-
-				if (variableName) {
-					const words = variableName.split(/\s+/).map(w => w.trim()).filter(Boolean);
-					if (words.length > 0) {
-						const regex = new RegExp(`\\b(${words.join('|')})\\b`, 'gi');
-						const stripped = fullName.replace(regex, '').replace(/\s{2,}/g, ' ').trim();
-						if (stripped !== '') fullName = stripped;
-					}
-				}
-
-				if (fullName.startsWith(font.typefaceName)) {
-					fullName = fullName.substring(font.typefaceName.length).trim();
-				}
-
-				if (sf.style?.toLowerCase() === 'italic' &&
-					!fullName.toLowerCase().endsWith('italic') &&
-					!fullName.toLowerCase().endsWith('slanted')) {
-					fullName = fullName + ' Italic';
-				}
-
-				if (fullName.trim().toLowerCase().endsWith('regular')) {
-					if (instanceName.trim().toLowerCase() + ' regular' === fullName.trim().toLowerCase()) return true;
-				}
-				if (fullName.trim().toLowerCase().startsWith('regular')) {
-					if ('regular ' + instanceName.trim().toLowerCase() === fullName.trim().toLowerCase()) return true;
-				}
-				if (fullName.trim().toLowerCase().endsWith('italic')) {
-					if (instanceName.trim().toLowerCase().endsWith('italic')) {
-						const k = instanceName.trim().toLowerCase().slice(0, -6).trim() + ' regular italic';
-						if (k === fullName.trim().toLowerCase()) return true;
-					}
-				}
+		// Collect all potential matches for this pass (don't claim yet)
+		const passMatches = [];
 
-				return fullName.trim().toLowerCase() === instanceName.trim().toLowerCase();
-			});
-		}
+		for (const inst of unmatched) {
+			// Get subfamily-scoped candidates that haven't been claimed
+			const subfamilyCandidates = filterBySubfamily(staticFonts, inst.parsed.subfamily, font.typefaceName)
+				.filter(sf => !claimedFontIds.has(sf._id));
 
-		// Strategy 3: Abbreviation expansion
-		if (!matchingFont) {
-			const expandedName = instanceName.split(' ').map(word => expandAbbreviations(word)).join(' ');
-			matchingFont = staticFonts.find(sf => {
-				const nameWithoutTypeface = sf.title.replace(font.typefaceName, '').trim();
-				return nameWithoutTypeface === expandedName;
-			});
+			const match = strategy.match(inst.name, inst.parsed, subfamilyCandidates, font.typefaceName, font);
+			if (match) {
+				passMatches.push({ instanceName: inst.name, font: match, strategy: strategy.name });
+			}
 		}
 
-		// Strategy 4: Weight + style matching
-		if (!matchingFont) {
-			const isItalic = instanceName.toLowerCase().includes('italic');
-			const weightTerms = [
-				{ term: 'thin', weight: '100' },
-				{ term: 'extralight', weight: '200' },
-				{ term: 'extra light', weight: '200' },
-				{ term: 'light', weight: '300' },
-				{ term: 'regular', weight: '400' },
-				{ term: 'normal', weight: '400' },
-				{ term: 'medium', weight: '500' },
-				{ term: 'semibold', weight: '600' },
-				{ term: 'semi bold', weight: '600' },
-				{ term: 'bold', weight: '700' },
-				{ term: 'extrabold', weight: '800' },
-				{ term: 'extra bold', weight: '800' },
-				{ term: 'black', weight: '900' },
-				{ term: 'heavy', weight: '900' },
-			];
-
-			let instanceWeight = '400';
-			for (const { term, weight } of weightTerms) {
-				if (instanceName.toLowerCase().includes(term)) {
-					instanceWeight = weight;
-					break;
-				}
+		// Claim matches — if multiple instances matched the same font, the first one wins
+		for (const m of passMatches) {
+			if (!claimedFontIds.has(m.font._id) && !results.has(m.instanceName)) {
+				results.set(m.instanceName, { fontId: m.font._id, strategy: m.strategy });
+				claimedFontIds.add(m.font._id);
 			}
-
-			matchingFont = staticFonts.find(sf =>
-				sf.weight === instanceWeight &&
-				((isItalic && sf.style === 'Italic') || (!isItalic && sf.style === 'Regular'))
-			);
 		}
+	}
 
-		// Strategy 5: weightName comparison
-		if (!matchingFont) {
-			matchingFont = staticFonts.find(sf => {
-				if (!sf.weightName) return false;
-				const cleanInstance = instanceName.toLowerCase().replace(/italic/i, '').trim();
-				const cleanWeight = sf.weightName.toLowerCase().replace(/italic/i, '').trim();
-				return cleanInstance === cleanWeight;
-			});
-		}
+	// Build output
+	const matched = [...results.values()].length;
+	console.log(`[parseVariableFontInstances] Matched ${matched}/${instanceNames.length} instances across ${STRATEGIES.length} passes`);
 
-		// Strategy 6: Legacy metaData.fullName fallback
-		if (!matchingFont && staticFonts.some(sf => sf.metaData?.fullName)) {
-			matchingFont = staticFonts.find(sf => {
-				if (!sf.metaData?.fullName) return false;
-				const typefacePattern = new RegExp(`^${font.typefaceName}\\s+`, 'i');
-				const stylePart = sf.metaData.fullName.replace(typefacePattern, '').trim();
-				return instanceName.toLowerCase() === stylePart.toLowerCase();
-			});
-		}
+	const instanceMappings = instanceNames.map(instanceName => {
+		const result = results.get(instanceName);
+		const matchedFont = result ? staticFonts.find(sf => sf._id === result.fontId) : null;
 
-		console.log(`Instance "${instanceName}" matched with:`, matchingFont ? matchingFont.title : 'No match found');
+		console.log(`Instance "${instanceName}" → ${matchedFont ? `${matchedFont.title} (${result.strategy})` : 'No match'}`);
 
-		instanceMappings.push({
+		return {
 			key: instanceName,
-			value: matchingFont
-				? { _type: 'reference', _ref: matchingFont._id, _weak: true }
+			value: matchedFont
+				? { _type: 'reference', _ref: matchedFont._id, _weak: true }
 				: null,
 			_key: nanoid(),
-		});
+		};
 	});
 
 	return instanceMappings;

package/src/utils/processFontFiles.js

@@ -168,16 +168,17 @@ export const extractFontMetadata = (font, title, weightKeywordList, italicKeywor
 
 	const fullName = getNameString(font, 4) || ttfFallbackMeta?.fullName || '';
 
-	if ((weightName === '' || weightName.toLowerCase() === 'roman') && fullName) {
+	const axes = getVariationAxes(font);
+	const variableFont = axes !== null;
+
+	// For non-VF fonts, fall back to extracting weight from fullName when weightName is empty
+	if (!variableFont && (weightName === '' || weightName.toLowerCase() === 'roman') && fullName) {
 		weightName = extractWeightFromFullName(font, title, ttfFallbackMeta);
 		if (!preserveShortenedNames) {
 			weightName = expandAbbreviations(weightName);
 		}
 	}
 
-	const axes = getVariationAxes(font);
-	const variableFont = axes !== null;
-
 	// Subfamily detection — extract width/optical variant from name table.
 	// Primary: nameId4 (fullName) minus typeface title — the most complete name record,
 	// always contains width + weight (e.g. "Gear XXNarrow Regular" → "XXNarrow Regular").

package/src/utils/updateTypefaceDocument.js

@@ -38,9 +38,22 @@ export const updateTypefaceDocument = async (
 
 	// Use dot-path keys so .set() does not clobber sibling fields
 	// (styles.collections, styles.pairs, styles.free, styles.displayStyles)
+	// Deduplicate by _ref to prevent duplicate entries on re-upload
+	const dedupeRefs = (existing, incoming) => {
+		const merged = [...(existing || [])];
+		const existingRefs = new Set(merged.map(r => r._ref).filter(Boolean));
+		incoming.forEach(ref => {
+			if (ref._ref && !existingRefs.has(ref._ref)) {
+				merged.push(ref);
+				existingRefs.add(ref._ref);
+			}
+		});
+		return merged;
+	};
+
 	let patch = {
-		'styles.fonts': stylesObject.fonts ? [...stylesObject.fonts, ...fontRefs] : [...fontRefs],
-		'styles.variableFont': stylesObject?.variableFont ? [...stylesObject.variableFont, ...variableRefs] : [...variableRefs],
+		'styles.fonts': dedupeRefs(stylesObject.fonts, fontRefs),
+		'styles.variableFont': dedupeRefs(stylesObject?.variableFont, variableRefs),
 	};
 
 	setStatus('Organising font subfamilies...');

package/dist/UploadModal-6LIX7XOK.js

@@ -1,6 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkFH4QKHOHjs = require('./chunk-FH4QKHOH.js');
-
-
-exports.default = _chunkFH4QKHOHjs.UploadModal;