@liiift-studio/sanity-font-manager 2.6.0 → 2.7.1

package/src/utils/regenerateFontData.js

@@ -1,146 +1,146 @@
-// Renames font document IDs across a typeface when a typeface slug changes
-
-import { parseFont } from './parseFont';
-import {
-	readFontFile,
-	extractFontMetadata,
-} from './processFontFiles';
-
-/**
- * Re-downloads TTF/OTF files for all fonts in a typeface and re-extracts their metadata,
- * patching each font document's title, slug, weightName, and subfamily.
- *
- * @param {Object} params
- * @param {Object} params.client - Sanity client
- * @param {string} params.typefaceName
- * @param {Object} params.slug - Typeface slug object
- * @param {string[]} params.weightKeywordList
- * @param {string[]} params.italicKeywordList
- * @param {boolean} params.preserveShortenedNames
- * @param {Function} params.setStatus
- * @param {Function} params.setError
- * @returns {Promise<Object>}
- */
-export const renameFontDocuments = async ({
-	client,
-	typefaceName,
-	slug,
-	weightKeywordList,
-	italicKeywordList,
-	preserveShortenedNames = false,
-	setStatus,
-	setError,
-}) => {
-	try {
-		if (!typefaceName) {
-			setStatus('Typeface needs a title');
-			setError(true);
-			console.error('Typeface needs title');
-			return { success: false, message: 'Typeface needs title' };
-		}
-
-		setStatus('Fetching font documents...');
-		const slugCurrent = slug?.current || typefaceName;
-
-		const query = await client.fetch(
-			`*[_type == "typeface" && slug.current == $slugCurrent][0]{
-				"fonts": styles.fonts[]->{ _id, title, subfamily, fileInput, style, weight, _key }
-			}`,
-			{ slugCurrent }
-		);
-		const fontDocuments = query?.fonts || [];
-
-		if (fontDocuments.length === 0) {
-			setStatus('No font documents found for this typeface');
-			setError(true);
-			return { success: false, message: 'No font documents found for this typeface' };
-		}
-
-		setStatus(`Found ${fontDocuments.length} font documents to process...`);
-
-		let updatedCount = 0;
-		let skippedCount = 0;
-		let errorCount = 0;
-
-		for (let i = 0; i < fontDocuments.length; i++) {
-			const fontDoc = fontDocuments[i];
-			setStatus(`Processing font ${i + 1}/${fontDocuments.length}: ${fontDoc.title}`);
-
-			if (!fontDoc.fileInput?.ttf?.asset?._ref && !fontDoc.fileInput?.otf?.asset?._ref) {
-				console.log(`Skipping ${fontDoc.title} — no TTF or OTF file found`);
-				skippedCount++;
-				continue;
-			}
-
-			try {
-				let file;
-				let ttfAsset;
-				let otfAsset;
-
-				if (fontDoc.fileInput?.ttf?.asset?._ref) {
-					ttfAsset = await client.getDocument(fontDoc.fileInput.ttf.asset._ref);
-				}
-
-				if (!ttfAsset?.url) {
-					if (fontDoc.fileInput?.otf?.asset?._ref) {
-						otfAsset = await client.getDocument(fontDoc.fileInput.otf.asset._ref);
-					}
-					if (!otfAsset?.url) {
-						console.log(`Skipping ${fontDoc.title} — no TTF or OTF URL`);
-						skippedCount++;
-						continue;
-					}
-					setStatus(`Fetching OTF file for ${fontDoc.title}...`);
-					const res = await fetch(otfAsset.url);
-					file = await res.blob();
-				} else {
-					setStatus(`Fetching TTF file for ${fontDoc.title}...`);
-					const res = await fetch(ttfAsset.url);
-					file = await res.blob();
-				}
-
-				const fontBuffer = await readFontFile(file);
-				const font = await parseFont(fontBuffer, `${fontDoc._id}.ttf`);
-
-				const { weightName, subfamilyName, fontTitle } = extractFontMetadata(
-					font,
-					typefaceName,
-					weightKeywordList,
-					italicKeywordList,
-					preserveShortenedNames,
-				);
-
-				const slugValue = fontTitle.toLowerCase().replace(/\s+/g, '-');
-
-				setStatus(`Updating font ${i + 1}/${fontDocuments.length}: ${fontTitle}`);
-				await client.patch(fontDoc._id)
-					.set({
-						title: fontTitle,
-						slug: { _type: 'slug', current: slugValue },
-						weightName: weightName,
-						subfamily: subfamilyName,
-					})
-					.commit();
-
-				updatedCount++;
-			} catch (err) {
-				console.error(`Error processing ${fontDoc.title}:`, err);
-				errorCount++;
-			}
-		}
-
-		const resultMessage = `Renamed ${updatedCount} of ${fontDocuments.length} font documents (${skippedCount} skipped, ${errorCount} errors)`;
-		setStatus(resultMessage);
-
-		return {
-			success: true,
-			message: resultMessage,
-			stats: { total: fontDocuments.length, updated: updatedCount, skipped: skippedCount, errors: errorCount },
-		};
-	} catch (err) {
-		console.error('Error renaming font documents:', err);
-		setError(true);
-		setStatus(`Error: ${err.message}`);
-		return { success: false, message: `Error: ${err.message}` };
-	}
-};
+// Renames font document IDs across a typeface when a typeface slug changes
+
+import { parseFont } from './parseFont';
+import {
+	readFontFile,
+	extractFontMetadata,
+} from './processFontFiles';
+
+/**
+ * Re-downloads TTF/OTF files for all fonts in a typeface and re-extracts their metadata,
+ * patching each font document's title, slug, weightName, and subfamily.
+ *
+ * @param {Object} params
+ * @param {Object} params.client - Sanity client
+ * @param {string} params.typefaceName
+ * @param {Object} params.slug - Typeface slug object
+ * @param {string[]} params.weightKeywordList
+ * @param {string[]} params.italicKeywordList
+ * @param {boolean} params.preserveShortenedNames
+ * @param {Function} params.setStatus
+ * @param {Function} params.setError
+ * @returns {Promise<Object>}
+ */
+export const renameFontDocuments = async ({
+	client,
+	typefaceName,
+	slug,
+	weightKeywordList,
+	italicKeywordList,
+	preserveShortenedNames = false,
+	setStatus,
+	setError,
+}) => {
+	try {
+		if (!typefaceName) {
+			setStatus('Typeface needs a title');
+			setError(true);
+			console.error('Typeface needs title');
+			return { success: false, message: 'Typeface needs title' };
+		}
+
+		setStatus('Fetching font documents...');
+		const slugCurrent = slug?.current || typefaceName;
+
+		const query = await client.fetch(
+			`*[_type == "typeface" && slug.current == $slugCurrent][0]{
+				"fonts": styles.fonts[]->{ _id, title, subfamily, fileInput, style, weight, _key }
+			}`,
+			{ slugCurrent }
+		);
+		const fontDocuments = query?.fonts || [];
+
+		if (fontDocuments.length === 0) {
+			setStatus('No font documents found for this typeface');
+			setError(true);
+			return { success: false, message: 'No font documents found for this typeface' };
+		}
+
+		setStatus(`Found ${fontDocuments.length} font documents to process...`);
+
+		let updatedCount = 0;
+		let skippedCount = 0;
+		let errorCount = 0;
+
+		for (let i = 0; i < fontDocuments.length; i++) {
+			const fontDoc = fontDocuments[i];
+			setStatus(`Processing font ${i + 1}/${fontDocuments.length}: ${fontDoc.title}`);
+
+			if (!fontDoc.fileInput?.ttf?.asset?._ref && !fontDoc.fileInput?.otf?.asset?._ref) {
+				console.log(`Skipping ${fontDoc.title} — no TTF or OTF file found`);
+				skippedCount++;
+				continue;
+			}
+
+			try {
+				let file;
+				let ttfAsset;
+				let otfAsset;
+
+				if (fontDoc.fileInput?.ttf?.asset?._ref) {
+					ttfAsset = await client.getDocument(fontDoc.fileInput.ttf.asset._ref);
+				}
+
+				if (!ttfAsset?.url) {
+					if (fontDoc.fileInput?.otf?.asset?._ref) {
+						otfAsset = await client.getDocument(fontDoc.fileInput.otf.asset._ref);
+					}
+					if (!otfAsset?.url) {
+						console.log(`Skipping ${fontDoc.title} — no TTF or OTF URL`);
+						skippedCount++;
+						continue;
+					}
+					setStatus(`Fetching OTF file for ${fontDoc.title}...`);
+					const res = await fetch(otfAsset.url);
+					file = await res.blob();
+				} else {
+					setStatus(`Fetching TTF file for ${fontDoc.title}...`);
+					const res = await fetch(ttfAsset.url);
+					file = await res.blob();
+				}
+
+				const fontBuffer = await readFontFile(file);
+				const font = await parseFont(fontBuffer, `${fontDoc._id}.ttf`);
+
+				const { weightName, subfamilyName, fontTitle } = extractFontMetadata(
+					font,
+					typefaceName,
+					weightKeywordList,
+					italicKeywordList,
+					preserveShortenedNames,
+				);
+
+				const slugValue = fontTitle.toLowerCase().replace(/\s+/g, '-');
+
+				setStatus(`Updating font ${i + 1}/${fontDocuments.length}: ${fontTitle}`);
+				await client.patch(fontDoc._id)
+					.set({
+						title: fontTitle,
+						slug: { _type: 'slug', current: slugValue },
+						weightName: weightName,
+						subfamily: subfamilyName,
+					})
+					.commit();
+
+				updatedCount++;
+			} catch (err) {
+				console.error(`Error processing ${fontDoc.title}:`, err);
+				errorCount++;
+			}
+		}
+
+		const resultMessage = `Renamed ${updatedCount} of ${fontDocuments.length} font documents (${skippedCount} skipped, ${errorCount} errors)`;
+		setStatus(resultMessage);
+
+		return {
+			success: true,
+			message: resultMessage,
+			stats: { total: fontDocuments.length, updated: updatedCount, skipped: skippedCount, errors: errorCount },
+		};
+	} catch (err) {
+		console.error('Error renaming font documents:', err);
+		setError(true);
+		setStatus(`Error: ${err.message}`);
+		return { success: false, message: `Error: ${err.message}` };
+	}
+};

package/src/utils/resolveExistingFont.js

@@ -1,87 +1,87 @@
-// Standalone document resolution — determines if a font already exists in Sanity
-
-import { RECOMMENDATION } from './planTypes';
-
-/**
- * Resolves whether a font document already exists in Sanity, returning match details
- * and a recommendation for how to proceed.
- *
- * Resolution strategies (in priority order):
- *   1. Exact _id match or draft _id match or slug.current match
- *   2. Content match by typefaceName + weightName + style + subfamily + variableFont
- *
- * @param {object} font - { _id, typefaceName, weightName, style, subfamily, variableFont, title }
- * @param {object} client - Sanity client (parameterized queries only)
- * @returns {Promise<{ exact: object|null, candidates: object[], recommendation: string, lookupFailed: boolean }>}
- */
-export const resolveExistingFont = async (font, client) => {
-	const result = {
-		exact: null,
-		candidates: [],
-		recommendation: RECOMMENDATION.CREATE,
-		lookupFailed: false,
-	};
-
-	try {
-		// Strategy 1: ID / slug match
-		const idMatches = await client.fetch(
-			`*[_type == 'font' && (_id == $id || _id == $draftId || slug.current == $id)]{
-				_id, title, weight, style, weightName, typefaceName, subfamily, variableFont,
-				fileInput, description, metaData, metrics, opentypeFeatures, characterSet,
-				scriptFileInput, variableInstanceReferences
-			}`,
-			{ id: font._id, draftId: `drafts.${font._id}` }
-		);
-
-		if (idMatches.length > 0) {
-			result.exact = idMatches[0];
-			result.recommendation = RECOMMENDATION.USE_EXACT;
-			return result;
-		}
-
-		// Strategy 2: Content match (only when ID query returns nothing)
-		const subfamily = font.subfamily || '';
-		const contentMatches = await client.fetch(
-			`*[_type == 'font'
-				&& lower(typefaceName) == lower($typefaceName)
-				&& lower(weightName) == lower($weightName)
-				&& lower(style) == lower($style)
-				&& (variableFont == $variableFont || (!defined(variableFont) && $variableFont == false))
-				&& (
-					lower(coalesce(subfamily, '')) == lower($subfamily)
-					|| (lower(coalesce(subfamily, '')) in ['', 'regular'] && lower($subfamily) in ['', 'regular'])
-				)
-			]{
-				_id, title, weight, style, weightName, typefaceName, subfamily, variableFont,
-				fileInput, description, metaData, metrics, opentypeFeatures, characterSet,
-				scriptFileInput, variableInstanceReferences
-			}`,
-			{
-				typefaceName: font.typefaceName,
-				weightName: font.weightName || '',
-				style: font.style || 'Regular',
-				variableFont: font.variableFont || false,
-				subfamily: subfamily === '' ? 'regular' : subfamily,
-			}
-		);
-
-		if (contentMatches.length === 1) {
-			result.candidates = contentMatches;
-			result.recommendation = RECOMMENDATION.USE_CANDIDATE;
-			return result;
-		}
-
-		if (contentMatches.length > 1) {
-			result.candidates = contentMatches;
-			result.recommendation = RECOMMENDATION.AMBIGUOUS;
-			console.warn(`Ambiguous font match for "${font.title}" — ${contentMatches.length} candidates found:`,
-				contentMatches.map(c => c._id));
-			return result;
-		}
-	} catch (err) {
-		console.error('Error resolving existing font:', font._id, err.message);
-		result.lookupFailed = true;
-	}
-
-	return result;
-};
+// Standalone document resolution — determines if a font already exists in Sanity
+
+import { RECOMMENDATION } from './planTypes';
+
+/**
+ * Resolves whether a font document already exists in Sanity, returning match details
+ * and a recommendation for how to proceed.
+ *
+ * Resolution strategies (in priority order):
+ *   1. Exact _id match or draft _id match or slug.current match
+ *   2. Content match by typefaceName + weightName + style + subfamily + variableFont
+ *
+ * @param {object} font - { _id, typefaceName, weightName, style, subfamily, variableFont, title }
+ * @param {object} client - Sanity client (parameterized queries only)
+ * @returns {Promise<{ exact: object|null, candidates: object[], recommendation: string, lookupFailed: boolean }>}
+ */
+export const resolveExistingFont = async (font, client) => {
+	const result = {
+		exact: null,
+		candidates: [],
+		recommendation: RECOMMENDATION.CREATE,
+		lookupFailed: false,
+	};
+
+	try {
+		// Strategy 1: ID / slug match
+		const idMatches = await client.fetch(
+			`*[_type == 'font' && (_id == $id || _id == $draftId || slug.current == $id)]{
+				_id, title, weight, style, weightName, typefaceName, subfamily, variableFont,
+				fileInput, description, metaData, metrics, opentypeFeatures, characterSet,
+				scriptFileInput, variableInstanceReferences
+			}`,
+			{ id: font._id, draftId: `drafts.${font._id}` }
+		);
+
+		if (idMatches.length > 0) {
+			result.exact = idMatches[0];
+			result.recommendation = RECOMMENDATION.USE_EXACT;
+			return result;
+		}
+
+		// Strategy 2: Content match (only when ID query returns nothing)
+		const subfamily = font.subfamily || '';
+		const contentMatches = await client.fetch(
+			`*[_type == 'font'
+				&& lower(typefaceName) == lower($typefaceName)
+				&& lower(weightName) == lower($weightName)
+				&& lower(style) == lower($style)
+				&& (variableFont == $variableFont || (!defined(variableFont) && $variableFont == false))
+				&& (
+					lower(coalesce(subfamily, '')) == lower($subfamily)
+					|| (lower(coalesce(subfamily, '')) in ['', 'regular'] && lower($subfamily) in ['', 'regular'])
+				)
+			]{
+				_id, title, weight, style, weightName, typefaceName, subfamily, variableFont,
+				fileInput, description, metaData, metrics, opentypeFeatures, characterSet,
+				scriptFileInput, variableInstanceReferences
+			}`,
+			{
+				typefaceName: font.typefaceName,
+				weightName: font.weightName || '',
+				style: font.style || 'Regular',
+				variableFont: font.variableFont || false,
+				subfamily: subfamily === '' ? 'regular' : subfamily,
+			}
+		);
+
+		if (contentMatches.length === 1) {
+			result.candidates = contentMatches;
+			result.recommendation = RECOMMENDATION.USE_CANDIDATE;
+			return result;
+		}
+
+		if (contentMatches.length > 1) {
+			result.candidates = contentMatches;
+			result.recommendation = RECOMMENDATION.AMBIGUOUS;
+			console.warn(`Ambiguous font match for "${font.title}" — ${contentMatches.length} candidates found:`,
+				contentMatches.map(c => c._id));
+			return result;
+		}
+	} catch (err) {
+		console.error('Error resolving existing font:', font._id, err.message);
+		result.lookupFailed = true;
+	}
+
+	return result;
+};

package/src/utils/retitleFontEntries.js

@@ -0,0 +1,154 @@
+// Lightweight retitle pass — re-derives title, documentId, weightName, and
+// subfamilyName from cached parsedMetadata when preserveShortenedNames changes.
+// No fontkit parsing, no file I/O, no Sanity queries — pure string manipulation.
+
+import { expandAbbreviations, generateStyleKeywords } from './generateKeywords.js';
+import { formatFontTitle, addItalicToFontTitle, processSubfamilyName } from './processFontFiles.js';
+import { sanitizeForSanityId } from './sanitizeForSanityId.js';
+
+const { weightKeywordList: WEIGHT_KW, italicKeywordList: ITALIC_KW } = generateStyleKeywords();
+
+/**
+ * Re-derive title, documentId, weightName, and subfamilyName for a single
+ * font entry using cached metadata and the new preserveShortenedNames setting.
+ * Skips entries with user overrides on title (user edits take precedence).
+ *
+ * @param {object} entry - Font plan entry with parsedMetadata and decisions
+ * @param {boolean} preserveShortenedNames - New setting value
+ * @param {string} typefaceTitle - Parent typeface title (for prefix stripping)
+ * @returns {object} Updated entry (shallow copy if changed, same ref if unchanged)
+ */
+export function retitleFontEntry(entry, preserveShortenedNames, typefaceTitle) {
+	if (!entry || !entry.parsedMetadata) return entry;
+
+	// Skip entries with user overrides on title — user edits take precedence
+	if (entry.decisions?.title?.userOverride) return entry;
+
+	const meta = entry.parsedMetadata;
+	const fullName = meta.fullName || '';
+	const familyName = meta.familyName || '';
+	const trimmedTitle = (typefaceTitle || '').trim();
+
+	// Re-derive weightName from the original detected value
+	let weightName = entry.decisions?.weightName?.detected || entry.weightName || '';
+	if (!preserveShortenedNames) {
+		weightName = expandAbbreviations(weightName);
+	}
+
+	// Re-derive subfamilyName
+	const nameId4Remainder = fullName ? fullName.replace(trimmedTitle, '').trim() : '';
+	const nameId1Remainder = familyName ? familyName.replace(trimmedTitle, '').trim() : '';
+	let subfamilyName = nameId4Remainder || nameId1Remainder;
+
+	if (!preserveShortenedNames) {
+		subfamilyName = expandAbbreviations(subfamilyName);
+	}
+
+	subfamilyName = processSubfamilyName(subfamilyName, WEIGHT_KW, ITALIC_KW, preserveShortenedNames);
+
+	// Strip style-only names from subfamily
+	subfamilyName = subfamilyName
+		.replace(/\b(Italic|Slant|Slanted|Oblique|Backslant|Roman|Upright)\b/gi, '')
+		.replace(/\s+/g, ' ')
+		.trim();
+
+	// Strip subfamily from weightName to avoid duplication
+	if (subfamilyName !== '') {
+		weightName = weightName
+			.replace(`${subfamilyName} `, '')
+			.replace(` ${subfamilyName}`, '')
+			.trim();
+	}
+
+	// Re-derive title
+	let fontTitle = fullName.trim() || '';
+	fontTitle = formatFontTitle(fontTitle, preserveShortenedNames);
+
+	// Variable fonts get " VF" suffix
+	if (entry.variableFont) {
+		if (!fontTitle.toLowerCase().includes('vf')) {
+			fontTitle = fontTitle + ' VF';
+		}
+		subfamilyName = '';
+	}
+
+	// Add italic suffix if needed
+	if (!(entry.variableFont && fontTitle.toLowerCase().includes('italic'))) {
+		// Build a minimal font-like object for addItalicToFontTitle
+		const italicKW = entry.parsedMetadata.italicAngle !== 0 ? 'Italic' : '';
+		fontTitle = addItalicToFontTitle(
+			{ opentype: { tables: { post: { italicAngle: entry.parsedMetadata.italicAngle || 0 } } } },
+			fontTitle,
+			italicKW,
+			entry.style,
+			preserveShortenedNames
+		);
+	}
+
+	const documentId = sanitizeForSanityId(fontTitle);
+
+	// Only return a new object if something actually changed
+	if (
+		entry.title === fontTitle &&
+		entry.documentId === documentId &&
+		entry.weightName === weightName &&
+		entry.subfamily === (entry.variableFont ? '' : (subfamilyName || 'Regular'))
+	) {
+		return entry;
+	}
+
+	const finalSubfamily = entry.variableFont ? '' : (subfamilyName || 'Regular');
+
+	return {
+		...entry,
+		title: fontTitle,
+		documentId,
+		weightName,
+		subfamily: finalSubfamily,
+		decisions: {
+			...entry.decisions,
+			title: { ...entry.decisions.title, processed: fontTitle },
+			documentId: { ...entry.decisions.documentId, generated: documentId },
+			weightName: { ...entry.decisions.weightName, detected: weightName },
+			subfamily: { ...entry.decisions.subfamily, detected: finalSubfamily },
+		},
+	};
+}
+
+/**
+ * Retitle all font entries in a plan. Returns a new fonts map.
+ * Runs collision detection after retitling.
+ *
+ * @param {object} fonts - plan.fonts map
+ * @param {boolean} preserveShortenedNames
+ * @param {string} typefaceTitle
+ * @returns {object} New fonts map with updated titles and _idConflict flags
+ */
+export function retitleAllFonts(fonts, preserveShortenedNames, typefaceTitle) {
+	const updated = {};
+	for (const [tempId, entry] of Object.entries(fonts)) {
+		updated[tempId] = retitleFontEntry(entry, preserveShortenedNames, typefaceTitle);
+	}
+
+	// Run collision detection
+	const idMap = {};
+	for (const [tempId, font] of Object.entries(updated)) {
+		updated[tempId] = { ...font, _idConflict: false };
+		const docId = font.documentId;
+		if (!idMap[docId]) {
+			idMap[docId] = [tempId];
+		} else {
+			idMap[docId].push(tempId);
+		}
+	}
+
+	for (const ids of Object.values(idMap)) {
+		if (ids.length > 1) {
+			for (const id of ids) {
+				updated[id] = { ...updated[id], _idConflict: true };
+			}
+		}
+	}
+
+	return updated;
+}