@liiift-studio/sanity-font-manager 2.7.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;
+};