Function validateRegistry

registry/scripts/validator.ts:531–686

(root: string)

};

export const validateRegistry = async (root: string): Promise<void> => {
	await validateCanonicalJson(join(root, 'upstreams.json'), upstreamsSchema);
	const familyKeys = await listFamilyKeys(root);
	const subsetIds = await listSubsetIds(root);
	const subsets = new Map(
		await Promise.all(
			subsetIds.map(
				async (id) => [id, await validateSubset(root, id)] as const,
			),
		),
	);
	const familyIds = new Set<string>();
	for (const family of familyKeys) {
		const { id } = parseFamilyKey(family);
		assert(!familyIds.has(id), `Duplicate registry family ID ${id}`);
		familyIds.add(id);
	}
	const replacements = await validateCanonicalJson(
		join(root, 'replacements.json'),
		replacementRegistrySchema,
	);
	const taxonomy = await validateCanonicalJson(
		join(root, 'taxonomy.json'),
		taxonomySchema,
	);
	const familyTags = await validateCanonicalJson(
		join(root, 'family-tags.json'),
		familyTagsSchema,
	);
	const familyOverrides = await validateCanonicalJson(
		join(root, 'family-overrides.json'),
		familyOverridesSchema,
	);
	const languages = await validateCanonicalJson(
		join(root, 'languages.json'),
		languageCatalogSchema,
	);
	for (const [id, language] of Object.entries(languages)) {
		if (!language.requiredCodepoints) continue;
		deepStrictEqual(
			language.requiredCodepoints,
			Array.from(new Set(language.requiredCodepoints)).toSorted(
				(left, right) => left - right,
			),
			`${id} required codepoints must be sorted and unique`,
		);
	}
	for (const tag of Object.keys(taxonomy.tags)) {
		const group = tag.split('/')[0] as string;
		assert(
			taxonomy.tagGroups[group],
			`${tag} references unknown group ${group}`,
		);
	}

	let validated = 0;
	const families = await Promise.all(
		familyKeys.map(async (family) => {