@jjlmoya/utils-cooking 1.2.0

package/src/tool/mold-scaler/i18n/fr.ts

@@ -0,0 +1,276 @@
+import type { ToolLocaleContent } from '../../../types';
+
+export const content: ToolLocaleContent = {
+	slug: 'adaptateur-taille-moule-patisserie',
+	title: 'Adaptateur de Taille de Moule et Calculateur de Cuisson',
+	description:
+		'Adaptez n’importe quelle recette de pâtisserie à vos moules instantanément. Calculez le facteur de conversion pour les moules ronds, carrés et rectangulaires avec une précision professionnelle.',
+	faqTitle: 'Questions Fréquentes sur la Conversion',
+	bibliographyTitle: 'Ressources Scientifiques et Références',
+
+	ui: {
+		originalRecipe: 'Recette Originale',
+		yourMold: 'Votre Moule',
+		round: 'Rond',
+		square: 'Carré',
+		rectangular: 'Rectangulaire',
+		diameter: 'Diamètre (cm)',
+		side: 'Côté (cm)',
+		width: 'Largeur (cm)',
+		length: 'Longueur (cm)',
+		multiplyingFactor: 'Facteur de Conversion',
+		equivalentMolds: 'Les moules sont équivalents. Utilisez les mêmes quantités.',
+		smallerMold: 'Votre moule est plus petit. Réduisez les ingrédients en les multipliant par',
+		largerMold: 'Votre moule est plus grand. Augmentez les ingrédients en les multipliant par',
+		ingredientCalculator: 'Calculateur de Poids d\'Ingrédients',
+		addIngredient: 'Ajouter un Ingrédient',
+		ingredient: 'Ingrédient',
+		original: 'Original',
+		final: 'Final',
+		exampleIngredient: 'Ex: Farine',
+		delete: 'Supprimer',
+		originalVisualization: 'Original',
+		yourVisualization: 'Le vôtre',
+		defaultIngredient1: 'Farine',
+		defaultIngredient2: 'Sucre',
+		reduce: 'Réduire',
+		increase: 'Augmenter',
+	},
+
+	faq: [
+		{
+			question: 'Comment est calculé exactement le facteur multiplicateur ?',
+			answer:
+				'Le facteur est obtenu en divisant la surface de votre moule cible par la surface du moule d\'origine mentionné dans la recette. Si le résultat est 1,5, vous multipliez chaque ingrédient par 1,5.',
+		},
+		{
+			question: 'Puis-je convertir un moule rond en un moule carré ?',
+			answer:
+				'Oui, notre outil utilise des formules géométriques pour comparer les surfaces quelle que soit la forme. Entrez simplement les dimensions et le système gère l\'équivalence automatiquement.',
+		},
+		{
+			question: 'La hauteur du moule affecte-t-elle le calcul ?',
+			answer:
+				'Cet outil se concentre sur la surface de base, qui est le facteur le plus critique. Si votre moule est beaucoup plus haut ou plus bas que l\'original, vous devrez peut-être ajuster le temps de cuisson.',
+		},
+		{
+			question: 'Comment ajouter plusieurs ingrédients à ma liste ?',
+			answer:
+				'Cliquez sur le bouton "Ajouter un Ingrédient" pour créer une nouvelle ligne. Tapez le nom et le poids original ; la colonne finale se met à jour instantanément avec le montant proportionnel.',
+		},
+		{
+			question: 'Le calcul est-il fiable pour les très grandes plaques ?',
+			answer:
+				'Mathématiquement oui, mais gardez à l\'esprit que les très gros gâteaux mettent plus de temps à cuire au centre. Vous devrez peut-être baisser la température du four légèrement.',
+		},
+	],
+
+	bibliography: [
+		{
+			name: 'Science et Technologie de la Boulangerie - E.J. Pyler',
+			url: 'https://www.bakingbusiness.com/',
+		},
+		{
+			name: 'Le Chef Pâtissier Professionnel - Bo Friberg',
+			url: 'https://www.wiley.com/',
+		},
+	],
+
+	howTo: [
+		{
+			name: 'Définissez le moule de la recette originale',
+			text: 'Sélectionnez la forme et les dimensions du moule pour lequel la recette a été initialement conçue.',
+		},
+		{
+			name: 'Saisissez les mesures de votre moule cible',
+			text: 'Sélectionnez la forme de votre moule et entrez ses dimensions. Le système calculera le facteur immédiatement.',
+		},
+		{
+			name: 'Utilisez le convertisseur de poids d\'ingrédients',
+			text: 'Ajoutez les ingrédients de votre recette pour voir exactement les quantités dont vous avez besoin pour la nouvelle taille.',
+		},
+		{
+			name: 'Surveillez les temps de cuisson',
+			text: 'N\'oubliez pas que changer la taille du moule nécessite généralement des ajustements de temps, même si la température reste la même.',
+		},
+	],
+
+	seo: [
+		{
+			type: 'title',
+			text: 'Guide Avancé pour Adapter vos Recettes selon la Taille du Moule',
+			level: 2,
+		},
+		{
+			type: 'paragraph',
+			html: 'Adapter les quantités d’une recette pour une taille de moule différente est une compétence fondamentale en pâtisserie professionnelle. Il ne s’agit pas seulement d’ajouter quelques ingrédients à l’œil ; cela nécessite de respecter les <strong>proportions géométriques</strong> pour maintenir la même hauteur et texture.',
+		},
+		{
+			type: 'diagnostic',
+			variant: 'info',
+			title: 'Le Secret de la Surface',
+			html: 'Le secret d’une bonne adaptation réside dans la surface, pas dans le diamètre. Une augmentation de 25 % du diamètre d’un moule rond double presque sa surface totale.',
+		},
+		{
+			type: 'stats',
+			columns: 4,
+			items: [
+				{
+					value: 'x1.56',
+					label: 'Facteur 20cm à 25cm',
+					icon: 'mdi:resize',
+				},
+				{
+					value: 'x2.25',
+					label: 'Facteur 15cm à 22.5cm',
+					icon: 'mdi:arrow-up-bold-outline',
+				},
+				{
+					value: '0.64',
+					label: 'Facteur 25cm à 20cm',
+					icon: 'mdi:arrow-down-bold-outline',
+				},
+				{
+					value: 'πr²',
+					label: 'Formule d’aire circulaire',
+					icon: 'mdi:math-compass',
+				},
+			],
+		},
+		{
+			type: 'title',
+			text: 'Comparaison des Formes et Efficacité Thermique',
+			level: 3,
+		},
+		{
+			type: 'comparative',
+			columns: 3,
+			items: [
+				{
+					title: 'Moules Ronds',
+					icon: 'mdi:circle-outline',
+					description: 'Le standard de la pâtisserie. Ils offrent une cuisson très uniforme de la périphérie vers le centre.',
+					points: [
+						'Distribution de chaleur optimale',
+						'Idéal pour gâteaux hauts',
+						'Calcul basé sur le rayon',
+					],
+				},
+				{
+					title: 'Moules Carrés',
+					icon: 'mdi:square-outline',
+					description: 'Permettent une utilisation maximale de l’espace. Idéal pour les brownies et les coupes individuelles nettes.',
+					highlight: true,
+					points: [
+						'Cuisson rapide des coins',
+						'Facile à portionner',
+						'Calcul Côté x Côté',
+					],
+				},
+				{
+					title: 'Moules Rectangulaires',
+					icon: 'mdi:rectangle-outline',
+					description: 'Parfaits pour les grands plateaux et les génoises. Nécessitent une surveillance au centre.',
+					points: [
+						'Capacité totale élevée',
+						'Polyvalence d’usage',
+						'Calcul Largeur x Longueur',
+					],
+				},
+			],
+		},
+		{
+			type: 'title',
+			text: 'Mathématiques de la Conversion de Surface',
+			level: 3,
+		},
+		{
+			type: 'paragraph',
+			html: 'Pour calculer le facteur de conversion correct, nous devons comparer les surfaces de base en utilisant ces formules géométriques standard :',
+		},
+		{
+			type: 'table',
+			headers: ['Forme du Moule', 'Formule de Surface', 'Considération Clé'],
+			rows: [
+				['Circulaire', 'π × Rayon²', 'Le rayon est la moitié du diamètre'],
+				['Carré', 'Côté × Côté', 'Mesures internes uniquement'],
+				['Rectangulaire', 'Largeur × Longueur', 'Standard pour les brownies et plaques'],
+			],
+		},
+		{
+			type: 'title',
+			text: 'Erreurs Courantes lors du Changement de Taille de Moule',
+			level: 3,
+		},
+		{
+			type: 'paragraph',
+			html: 'De nombreux pâtissiers amateurs font l’erreur d’adapter les ingrédients de manière linéaire en se basant sur le diamètre. Évitez ces pièges courants :',
+		},
+		{
+			type: 'list',
+			items: [
+				'<strong>Adaptation linéaire :</strong> Doubler le diamètre ne double pas les ingrédients ; cela les quadruple.',
+				'<strong>Ignorer la profondeur :</strong> Des moules profonds nécessitent une cuisson plus longue à basse température.',
+				'<strong>Agents levants :</strong> La levure chimique ne nécessite pas toujours une adaptation parfaitement linéaire.',
+				'<strong>Évaporation :</strong> Les petites quantités peuvent sécher plus vite à cause du ratio surface-volume.',
+			],
+		},
+		{
+			type: 'diagnostic',
+			variant: 'warning',
+			title: 'Limite de Capacité du Moule',
+			html: 'Ne remplissez jamais un moule à plus des 2/3 de sa capacité totale, quel que soit le facteur calculé, pour permettre une expansion correcte.',
+		},
+		{
+			type: 'title',
+			text: 'Glossaire des Termes de Conversion Géométrique',
+			level: 3,
+		},
+		{
+			type: 'glossary',
+			items: [
+				{
+					term: 'Facteur de Conversion',
+					definition: 'Le nombre par lequel multiplier tous les ingrédients pour adapter la recette au nouveau moule.',
+				},
+				{
+					term: 'Surface de Base',
+					definition: 'La mesure de l’aire du fond du moule. En pâtisserie, c’est la donnée la plus pertinente pour le volume.',
+				},
+				{
+					term: 'Rayon',
+					definition: 'Distance du centre vers le bord d’un cercle. Essentiel pour la formule πr².',
+				},
+				{
+					term: 'Transfert Thermique',
+					definition: 'La manière dont l’énergie voyage dans le moule. Change drastiquement selon la forme et le matériau.',
+				},
+			],
+		},
+		{
+			type: 'title',
+			text: 'Conseils de Pro pour la Cuisson des Recettes Adaptées',
+			level: 3,
+		},
+		{
+			type: 'tip',
+			html: 'Si vous passez à un moule beaucoup plus grand, utilisez des bandes de cuisson ou un noyau thermique au centre pour assurer une distribution uniforme de la chaleur sans dessécher les bords.',
+		},
+		{
+			type: 'paragraph',
+			html: 'Maîtriser l’adaptation des moules vous donne une liberté créative totale. Utilisez cette calculatrice pour éliminer les approximations et obtenir des résultats professionnels constants.',
+		},
+	],
+
+	schemas: [
+		{
+			'@context': 'https://schema.org',
+			'@type': 'WebApplication',
+			'name': 'Calculateur de Moule JJLMoya',
+			'url': 'https://utils.jjlmoya.com/fr/adaptateur-taille-moule-patisserie',
+			'description': 'Outil professionnel pour convertir le poids des ingrédients entre différentes tailles et formes de moules à pâtisserie.',
+			'applicationCategory': 'UtilitiesApplication',
+			'operatingSystem': 'All',
+		},
+	],
+};

package/src/tool/mold-scaler/index.ts

@@ -0,0 +1,26 @@
+import type { CookingToolEntry, ToolDefinition } from '../../types';
+import MoldScalerComponent from './component.astro';
+import MoldScalerSEO from './seo.astro';
+import MoldScalerBibliography from './bibliography.astro';
+
+export const moldScaler: CookingToolEntry = {
+	id: 'mold-scaler',
+	icons: {
+		bg: 'mdi:cake',
+		fg: 'mdi:resize',
+	},
+	i18n: {
+		es: () => import('./i18n/es').then((m) => m.content),
+		en: () => import('./i18n/en').then((m) => m.content),
+		fr: () => import('./i18n/fr').then((m) => m.content),
+	},
+};
+
+export { MoldScalerComponent, MoldScalerSEO, MoldScalerBibliography };
+
+export const MOLD_SCALER_TOOL: ToolDefinition = {
+	entry: moldScaler,
+	Component: MoldScalerComponent,
+	SEOComponent: MoldScalerSEO,
+	BibliographyComponent: MoldScalerBibliography,
+};

package/src/tool/mold-scaler/init.ts

@@ -0,0 +1,264 @@
+type Shape = 'round' | 'square' | 'rectangular';
+
+interface Mold {
+	shape: Shape;
+	dim1: number;
+	dim2: number;
+}
+
+interface Ingredient {
+	id: string;
+	name: string;
+	weight: number;
+}
+
+interface MoldScalerState {
+	original: Mold;
+	target: Mold;
+	ingredients: Ingredient[];
+	factor: number;
+}
+
+interface MoldScalerElements {
+	originalInputs: HTMLElement | null;
+	targetInputs: HTMLElement | null;
+	resultFactor: HTMLElement | null;
+	resultText: HTMLElement | null;
+	shapeOriginal: SVGPathElement | null;
+	shapeTarget: SVGPathElement | null;
+	ingredientsList: HTMLElement | null;
+	addBtn: HTMLElement | null;
+}
+
+interface MoldScalerContext {
+	state: MoldScalerState;
+	els: MoldScalerElements;
+	ui: Record<string, string>;
+}
+
+class MoldLogic {
+	static getArea(mold: Mold): number {
+		if (mold.shape === 'round') {
+			return Math.PI * Math.pow(mold.dim1 / 2, 2);
+		}
+		if (mold.shape === 'square') {
+			return mold.dim1 * mold.dim1;
+		}
+		return mold.dim1 * mold.dim2;
+	}
+
+	static getPath(mold: Mold, scale = 6): string {
+		if (mold.shape === 'round') {
+			const r = (mold.dim1 / 2) * scale;
+			return `M 0,${-r} A ${r},${r} 0 1,1 0,${r} A ${r},${r} 0 1,1 0,${-r}`;
+		}
+		const w = mold.dim1 * scale;
+		const h = (mold.shape === 'square' ? mold.dim1 : mold.dim2) * scale;
+		const x = -w / 2;
+		const y = -h / 2;
+		return `M ${x},${y} h ${w} v ${h} h ${-w} Z`;
+	}
+
+	static calculateFactor(original: Mold, target: Mold): number {
+		const area1 = this.getArea(original);
+		const area2 = this.getArea(target);
+		return Math.round((area2 / area1) * 100) / 100;
+	}
+}
+
+function getInputHtml(shape: Shape, mold: Mold, type: string, ui: Record<string, string>): string {
+	if (shape === 'round') {
+		return `<div class="ms-input-group"><label class="ms-label">${ui.diameter}</label><input type="number" class="ms-input" value="${mold.dim1}" min="1" step="0.5" data-type="${type}" data-key="dim1"></div>`;
+	}
+	if (shape === 'square') {
+		return `<div class="ms-input-group"><label class="ms-label">${ui.side}</label><input type="number" class="ms-input" value="${mold.dim1}" min="1" step="0.5" data-type="${type}" data-key="dim1"></div>`;
+	}
+	return `<div class="ms-inputs-grid"><div class="ms-input-group"><label class="ms-label">${ui.width}</label><input type="number" class="ms-input" value="${mold.dim1}" min="1" step="0.5" data-type="${type}" data-key="dim1"></div><div class="ms-input-group"><label class="ms-label">${ui.length}</label><input type="number" class="ms-input" value="${mold.dim2}" min="1" step="0.5" data-type="${type}" data-key="dim2"></div></div>`;
+}
+
+function renderInput(ctx: MoldScalerContext, type: 'original' | 'target'): void {
+	const container = type === 'original' ? ctx.els.originalInputs : ctx.els.targetInputs;
+	if (!container) return;
+	const html = getInputHtml(ctx.state[type].shape, ctx.state[type], type, ctx.ui);
+	container.innerHTML = html;
+}
+
+function buildIngredientRow(ing: Ingredient, factor: number, ui: Record<string, string>): string {
+	const finalValue = Math.round(ing.weight * factor);
+	return `<div class="ms-ingredient-row" data-id="${ing.id}"><div class="ms-input-group"><label class="ms-label">${ui.ingredient}</label><input type="text" class="ms-input ms-ing-name" value="${ing.name}" placeholder="${ui.exampleIngredient}"></div><div class="ms-input-group"><label class="ms-label">${ui.original}</label><input type="number" class="ms-input ms-ing-weight" value="${ing.weight || ''}" placeholder="0"></div><div class="ms-input-group"><label class="ms-label">${ui.final}</label><div class="ms-ingredient-final">${ing.weight > 0 ? `${finalValue}g` : '-'}</div></div><button class="ms-del-btn" data-id="${ing.id}" title="${ui.delete}"><svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg></button></div>`;
+}
+
+function bindNameInputs(ctx: MoldScalerContext): void {
+	ctx.els.ingredientsList?.querySelectorAll('.ms-ing-name').forEach((input) => {
+		const inp = input as HTMLInputElement;
+		inp.addEventListener('change', (e: Event) => {
+			const target = e.target as HTMLInputElement;
+			const id = target.closest('.ms-ingredient-row')?.getAttribute('data-id') ?? '';
+			const ing = ctx.state.ingredients.find((i: Ingredient) => i.id === id);
+			if (ing) ing.name = target.value;
+		});
+	});
+}
+
+function bindWeightInputs(ctx: MoldScalerContext, updateUI: () => void): void {
+	ctx.els.ingredientsList?.querySelectorAll('.ms-ing-weight').forEach((input) => {
+		const inp = input as HTMLInputElement;
+		inp.addEventListener('input', (e: Event) => {
+			const target = e.target as HTMLInputElement;
+			const id = target.closest('.ms-ingredient-row')?.getAttribute('data-id') ?? '';
+			const ing = ctx.state.ingredients.find((i: Ingredient) => i.id === id);
+			if (ing) {
+				ing.weight = parseFloat(target.value) || 0;
+				updateUI();
+			}
+		});
+	});
+}
+
+function bindDeleteButtons(ctx: MoldScalerContext, updateUI: () => void): void {
+	ctx.els.ingredientsList?.querySelectorAll('.ms-del-btn').forEach((btn) => {
+		const button = btn as HTMLButtonElement;
+		button.addEventListener('click', (e: Event) => {
+			const id = (e.currentTarget as HTMLElement).getAttribute('data-id') ?? '';
+			ctx.state.ingredients = ctx.state.ingredients.filter((i: Ingredient) => i.id !== id);
+			renderIngredients(ctx, updateUI);
+		});
+	});
+}
+
+function bindIngredientEvents(ctx: MoldScalerContext, updateUI: () => void): void {
+	bindNameInputs(ctx);
+	bindWeightInputs(ctx, updateUI);
+	bindDeleteButtons(ctx, updateUI);
+}
+
+function renderIngredients(ctx: MoldScalerContext, updateUI: () => void): void {
+	if (!ctx.els.ingredientsList) return;
+
+	if (ctx.state.ingredients.length === 0) {
+		ctx.els.ingredientsList.innerHTML = `<div class="ms-empty-state">${ctx.ui.addIngredient}</div>`;
+		return;
+	}
+
+	ctx.els.ingredientsList.innerHTML = ctx.state.ingredients.map((ing: Ingredient) => buildIngredientRow(ing, ctx.state.factor, ctx.ui)).join('');
+	bindIngredientEvents(ctx, updateUI);
+}
+
+function updateResultText(ctx: MoldScalerContext): void {
+	if (!ctx.els.resultText) return;
+	if (ctx.state.factor === 1) {
+		ctx.els.resultText.innerHTML = ctx.ui.equivalentMolds;
+	} else if (ctx.state.factor < 1) {
+		ctx.els.resultText.innerHTML = `${ctx.ui.smallerMold} <strong>${ctx.state.factor}</strong>.`;
+	} else {
+		ctx.els.resultText.innerHTML = `${ctx.ui.largerMold} <strong>${ctx.state.factor}</strong>.`;
+	}
+}
+
+function updateUI(ctx: MoldScalerContext): void {
+	ctx.state.factor = MoldLogic.calculateFactor(ctx.state.original, ctx.state.target);
+
+	if (ctx.els.resultFactor) {
+		ctx.els.resultFactor.textContent = `x${ctx.state.factor.toFixed(2)}`;
+	}
+
+	updateResultText(ctx);
+
+	if (ctx.els.shapeOriginal) {
+		ctx.els.shapeOriginal.setAttribute('d', MoldLogic.getPath(ctx.state.original));
+	}
+	if (ctx.els.shapeTarget) {
+		ctx.els.shapeTarget.setAttribute('d', MoldLogic.getPath(ctx.state.target));
+	}
+
+	const finalElements = document.querySelectorAll('.ms-ingredient-final');
+	ctx.state.ingredients.forEach((ing: Ingredient, index: number) => {
+		const el = finalElements[index];
+		if (el) {
+			const final = Math.round(ing.weight * ctx.state.factor);
+			el.textContent = ing.weight > 0 ? `${final}g` : '-';
+		}
+	});
+}
+
+function bindShapeButtons(ctx: MoldScalerContext, updateFn: () => void): void {
+	document.querySelectorAll('.ms-shape-btn').forEach((btn) => {
+		btn.addEventListener('click', (e) => {
+			const b = e.currentTarget as HTMLElement;
+			const target = b.dataset.target as 'original' | 'target' | undefined;
+			const shape = b.dataset.shape as Shape | undefined;
+
+			if ((target === 'original' || target === 'target') && shape) {
+				ctx.state[target].shape = shape;
+				document.querySelectorAll(`.ms-shape-btn[data-target="${target}"]`).forEach((btn) => {
+					btn.classList.toggle('active', btn === b);
+				});
+				renderInput(ctx, target);
+				updateFn();
+			}
+		});
+	});
+}
+
+function bindDimensionInputs(ctx: MoldScalerContext, updateFn: () => void): void {
+	[ctx.els.originalInputs, ctx.els.targetInputs].forEach((container) => {
+		container?.addEventListener('input', (e: Event) => {
+			const input = e.target as HTMLInputElement;
+			const type = input.dataset.type as 'original' | 'target' | undefined;
+			const key = input.dataset.key as 'dim1' | 'dim2' | undefined;
+
+			if ((type === 'original' || type === 'target') && (key === 'dim1' || key === 'dim2')) {
+				ctx.state[type][key] = parseFloat(input.value) || 0;
+				updateFn();
+			}
+		});
+	});
+}
+
+function bindAddButton(ctx: MoldScalerContext): void {
+	ctx.els.addBtn?.addEventListener('click', () => {
+		ctx.state.ingredients.push({
+			id: Math.random().toString(36).slice(2, 11),
+			name: '',
+			weight: 0,
+		});
+		renderIngredients(ctx, () => updateUI(ctx));
+	});
+}
+
+export function initMoldScaler(ui: Record<string, string>): void {
+	const state = {
+		original: { shape: 'round' as Shape, dim1: 20, dim2: 20 },
+		target: { shape: 'round' as Shape, dim1: 20, dim2: 20 },
+		ingredients: [
+			{ id: '1', name: ui.defaultIngredient1, weight: 0 },
+			{ id: '2', name: ui.defaultIngredient2, weight: 0 },
+		] as Ingredient[],
+		factor: 1,
+	};
+
+	const els = {
+		originalInputs: document.getElementById('original-inputs') as HTMLElement | null,
+		targetInputs: document.getElementById('target-inputs') as HTMLElement | null,
+		resultFactor: document.getElementById('result-factor') as HTMLElement | null,
+		resultText: document.getElementById('result-text') as HTMLElement | null,
+		shapeOriginal: document.getElementById('shape-original') as SVGPathElement | null,
+		shapeTarget: document.getElementById('shape-target') as SVGPathElement | null,
+		ingredientsList: document.getElementById('ingredients-list') as HTMLElement | null,
+		addBtn: document.getElementById('add-ingredient-btn') as HTMLElement | null,
+	};
+
+	const ctx: MoldScalerContext = { state, els, ui };
+	const updateFn = () => updateUI(ctx);
+
+	renderInput(ctx, 'original');
+	renderInput(ctx, 'target');
+	renderIngredients(ctx, updateFn);
+	bindShapeButtons(ctx, updateFn);
+	bindDimensionInputs(ctx, updateFn);
+	bindAddButton(ctx);
+	updateFn();
+}
+
+
+

package/src/tool/mold-scaler/seo.astro

@@ -0,0 +1,8 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { content } from './i18n/es';
+
+const locale = 'es';
+---
+
+<SEORenderer content={{ sections: content.seo, locale }} />