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

package/src/utils/regenerateFontData.js

@@ -1,146 +1,146 @@
-// Renames font document IDs across a typeface when a typeface slug changes
-
-import * as fontkit from 'fontkit';
-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 = fontkit.create(fontBuffer);
-
-				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

@@ -0,0 +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;
+};

package/src/utils/sanitizeForSanityId.js

@@ -1,65 +1,65 @@
-// Converts arbitrary strings into valid Sanity document IDs (lowercase, hyphens, no special characters)
-import slugify from 'slugify';
-
-/**
- * Sanitizes a string into a valid Sanity document ID.
- *
- * Sanity ID requirements:
- * - Must start with a letter or underscore (not a number or hyphen)
- * - Can only contain lowercase letters (a-z), numbers (0-9), hyphens (-), and underscores (_)
- * - Must be between 1 and 128 characters
- *
- * @param {string} str - The raw string (e.g. font title or filename) to sanitize
- * @returns {string} A valid Sanity document ID
- */
-export function sanitizeForSanityId(str) {
-	if (!str || typeof str !== 'string') {
-		return 'font-' + Date.now();
-	}
-
-	let sanitized = str.toLowerCase().trim();
-
-	// Replace common symbols before slugify
-	sanitized = sanitized.replace(/\+/g, 'plus');
-	sanitized = sanitized.replace(/&/g, 'and');
-	sanitized = sanitized.replace(/@/g, 'at');
-
-	sanitized = slugify(sanitized, {
-		replacement: '-',
-		remove: /[^\w\s-]/g,
-		lower: true,
-		strict: true,
-		locale: 'en',
-		trim: true,
-	});
-
-	// Strip any characters that still aren't lowercase-alphanumeric, hyphens, or underscores
-	sanitized = sanitized.replace(/[^a-z0-9\-_]/g, '-');
-
-	// Collapse repeated hyphens and strip leading/trailing hyphens or underscores
-	sanitized = sanitized.replace(/-+/g, '-');
-	sanitized = sanitized.replace(/^[-_]+|[-_]+$/g, '');
-
-	// IDs must not start with a number or hyphen
-	if (sanitized && !/^[a-z_]/.test(sanitized)) {
-		sanitized = 'font_' + sanitized;
-	}
-
-	if (!sanitized) {
-		sanitized = 'font_' + Date.now();
-	}
-
-	// Sanity hard-caps IDs at 128 characters
-	if (sanitized.length > 128) {
-		const hash = Math.random().toString(36).substring(2, 8);
-		sanitized = sanitized.substring(0, 120) + '_' + hash;
-	}
-
-	// Paranoid final validation
-	if (!/^[a-z_][a-z0-9\-_]*$/.test(sanitized)) {
-		console.warn(`ID sanitization produced invalid result: "${sanitized}", using fallback`);
-		sanitized = 'font_' + Date.now();
-	}
-
-	return sanitized;
-}
+// Converts arbitrary strings into valid Sanity document IDs (lowercase, hyphens, no special characters)
+import slugify from 'slugify';
+
+/**
+ * Sanitizes a string into a valid Sanity document ID.
+ *
+ * Sanity ID requirements:
+ * - Must start with a letter or underscore (not a number or hyphen)
+ * - Can only contain lowercase letters (a-z), numbers (0-9), hyphens (-), and underscores (_)
+ * - Must be between 1 and 128 characters
+ *
+ * @param {string} str - The raw string (e.g. font title or filename) to sanitize
+ * @returns {string} A valid Sanity document ID
+ */
+export function sanitizeForSanityId(str) {
+	if (!str || typeof str !== 'string') {
+		return 'font-' + Date.now();
+	}
+
+	let sanitized = str.toLowerCase().trim();
+
+	// Replace common symbols before slugify
+	sanitized = sanitized.replace(/\+/g, 'plus');
+	sanitized = sanitized.replace(/&/g, 'and');
+	sanitized = sanitized.replace(/@/g, 'at');
+
+	sanitized = slugify(sanitized, {
+		replacement: '-',
+		remove: /[^\w\s-]/g,
+		lower: true,
+		strict: true,
+		locale: 'en',
+		trim: true,
+	});
+
+	// Strip any characters that still aren't lowercase-alphanumeric, hyphens, or underscores
+	sanitized = sanitized.replace(/[^a-z0-9\-_]/g, '-');
+
+	// Collapse repeated hyphens and strip leading/trailing hyphens or underscores
+	sanitized = sanitized.replace(/-+/g, '-');
+	sanitized = sanitized.replace(/^[-_]+|[-_]+$/g, '');
+
+	// IDs must not start with a number or hyphen
+	if (sanitized && !/^[a-z_]/.test(sanitized)) {
+		sanitized = 'font_' + sanitized;
+	}
+
+	if (!sanitized) {
+		sanitized = 'font_' + Date.now();
+	}
+
+	// Sanity hard-caps IDs at 128 characters
+	if (sanitized.length > 128) {
+		const hash = Math.random().toString(36).substring(2, 8);
+		sanitized = sanitized.substring(0, 120) + '_' + hash;
+	}
+
+	// Paranoid final validation
+	if (!/^[a-z_][a-z0-9\-_]*$/.test(sanitized)) {
+		console.warn(`ID sanitization produced invalid result: "${sanitized}", using fallback`);
+		sanitized = 'font_' + Date.now();
+	}
+
+	return sanitized;
+}