@jjlmoya/utils-cooking 1.2.0

package/src/tool/ingredient-rescaler/i18n/es.ts

@@ -0,0 +1,268 @@
+import type { ToolLocaleContent } from '../../../types';
+
+export const content: ToolLocaleContent = {
+  slug: 'escalador-ingredientes',
+  title: 'Escalador de Ingredientes Ajuste de Recetas',
+  description: 'Escala recetas automáticamente según el número de raciones. Calcula las cantidades exactas de ingredientes multiplicando o reduciendo tu receta sin complicaciones.',
+  ui: {
+    servings: 'Raciones',
+    original: 'Original',
+    desired: 'Deseado',
+    multiplyingFactor: 'Factor Multiplicador',
+    ingredientsList: 'Lista de Ingredientes',
+    pasteHere: 'Pega aquí tu lista.',
+    exampleLine1: 'Ej:',
+    exampleLine2: '500g Harina',
+    exampleLine3: '300ml Agua',
+    exampleLine4: '10g Sal',
+    result: 'Resultado',
+    copy: 'Copiar',
+    copied: 'Copiado!',
+    emptyState: 'Tus ingredientes ajustados aparecerán aquí...',
+    defaultIngredient1: '200g Harina',
+    defaultIngredient2: '100ml Leche',
+    defaultIngredient3: '2 Huevos',
+  },
+  faqTitle: 'Preguntas Frecuentes',
+  faq: [
+    {
+      question: '¿Por qué mi factor de conversión incluye decimales?',
+      answer: 'Porque las proporciones culinarias no siempre son redondas. Si escalas una receta para 4 personas a 7, el factor es 1.75 exactamente. Los ingredientes se multiplican por ese número, aunque encuentres fracciones. Es más exacto que redondear arbitrariamente.',
+    },
+    {
+      question: '¿Qué pasa si ingreso "1/2 cucharadita de sal"?',
+      answer: 'El parser busca el número primero. Reconocerá "1" como cantidad, luego "/2" como parte de la unidad. El resultado será "0.5", y al escalar se multiplicará correctamente. Para fracciones como "1/2", ingresa "0.5" directamente (más claro) o la herramienta las interpreta como división.',
+    },
+    {
+      question: '¿Debo redondear los resultados finales?',
+      answer: 'Depende del ingrediente. Para harinas, sí. Para levaduras o especias, la precisión importa menos (escala al 75% de lo indicado). Para huevos: si obtienes 2.3, usa 2 completos + parte de un tercero (pesada), o redondea a 2 si el plato lo permite.',
+    },
+    {
+      question: '¿Por qué no cambia el resultado cuando cambio las raciones?',
+      answer: 'Asegúrate de que el campo de ingredientes tenga contenido. Si está vacío, no hay nada que escalar. También verifica que los números en tus ingredientes sean reconocibles (ej: "500g", "1/2 cucharadita").',
+    },
+    {
+      question: '¿Funciona con medidas imperiales (onzas, tazas)?',
+      answer: 'Técnicamente sí, la herramienta lee números y escala. Pero la precisión es limitada con tazas (volumen inconsistente). Se recomienda convertir a gramos antes de escalar.',
+    },
+  ],
+  bibliographyTitle: 'Bibliografía',
+  bibliography: [
+    {
+      name: 'Harold McGee - On Food and Cooking: The Science and Lore of the Kitchen',
+      url: 'https://en.wikipedia.org/wiki/Harold_McGee',
+    },
+    {
+      name: 'The Flavor Bible by Karen Page and Andrew Dornenburg',
+      url: 'https://www.flavorprints.com/',
+    },
+    {
+      name: 'Modernist Cuisine - Técnicas de escalado científico',
+      url: 'https://www.modernistcuisine.com/',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Ingresa tus raciones',
+      text: 'En el campo "Original", coloca el número de personas para el que la receta está diseñada. En "Deseado", coloca el número de personas que vas a cocinar.',
+    },
+    {
+      name: 'Pega tu lista de ingredientes',
+      text: 'Copia y pega tu lista tal cual. Cada ingrediente en una línea. La herramienta reconoce números al inicio (500g, 1/2, 2.5) y escala automáticamente.',
+    },
+    {
+      name: 'Ajusta según contexto',
+      text: 'Los resultados son matemáticamente exactos, pero la cocina es arte. Especias: escala al 75%. Levaduras: menos de lo teórico en grandes cantidades. Tiempos: no se escalan nunca.',
+    },
+  ],
+	seo: [
+		{
+			type: 'title',
+			text: 'Guía Maestro para el Escalado y Conversión de Recetas',
+			level: 2,
+		},
+		{
+			type: 'paragraph',
+			html: 'El <strong>escalado de ingredientes</strong> es una de las tareas más críticas y propensas a errores en la cocina profesional. No se trata simplemente de multiplicar números, sino de entender cómo la química y la física de los alimentos reaccionan ante cambios de volumen y superficie.',
+		},
+		{
+			type: 'stats',
+			columns: 4,
+			items: [
+				{
+					value: 'x1.75',
+					label: 'Factor de 4 a 7 per.',
+					icon: 'mdi:calculator',
+				},
+				{
+					value: '75%',
+					label: 'Ajuste de Especias',
+					icon: 'mdi:shaker-outline',
+				},
+				{
+					value: '0%',
+					label: 'Escalado del Tiempo',
+					icon: 'mdi:timer-off',
+				},
+				{
+					value: '100g',
+					label: 'Base de Referencia',
+					icon: 'mdi:weight-gram',
+				},
+			],
+		},
+		{
+			type: 'title',
+			text: 'Diferencias entre Escalado Lineal y Contextual',
+			level: 3,
+		},
+		{
+			type: 'comparative',
+			columns: 2,
+			items: [
+				{
+					title: 'Escalado Lineal Matemático',
+					icon: 'mdi:math-log',
+					description: 'Multiplicación directa de todos los valores por el factor de conversión obtenido.',
+					points: [
+						'Perfecto para harinas y líquidos base',
+						'Ideal para repostería de precisión fría',
+						'Funciona bien en cambios pequeños (x2, x0.5)',
+						'Fácil de calcular automáticamente',
+					],
+				},
+				{
+					title: 'Escalado Contextual de Cocina',
+					icon: 'mdi:chef-hat',
+					description: 'Ajuste de proporciones basado en la saturación de sabor y evaporación.',
+					highlight: true,
+					points: [
+						'Evita el exceso de sal y especias',
+						'Considera la superficie de evaporación',
+						'Ajusta levaduras según fricción',
+						'Requiere experiencia y criterio del chef',
+					],
+				},
+			],
+		},
+		{
+			type: 'title',
+			text: 'Factores de Conversión por Número de Comensales',
+			level: 3,
+		},
+		{
+			type: 'table',
+			headers: ['De Raciones', 'A Raciones', 'Factor (FC)', 'Dificultad de Ajuste'],
+			rows: [
+				['2 personas', '4 personas', 'x 2.0', 'Baja (Lineal)'],
+				['4 personas', '6 personas', 'x 1.5', 'Baja (Lineal)'],
+				['4 personas', '10 personas', 'x 2.5', 'Media (Ojo con especias)'],
+				['4 personas', '25 personas', 'x 6.25', 'Alta (Contextual)'],
+			],
+		},
+		{
+			type: 'diagnostic',
+			variant: 'warning',
+			title: 'Problemas Comunes al Doblar una Receta',
+			html: 'Si notas que el sabor es demasiado intenso tras escalar (especialmente con picantes o sal), reduce el escalado de estos ingredientes específicos al 75%. Nunca dupliques el tiempo de cocción; la temperatura interna se alcanza según el grosor de la pieza, no según el peso total de la masa.',
+		},
+		{
+			type: 'title',
+			text: 'Glosario de Terminología de Estandarización',
+			level: 3,
+		},
+		{
+			type: 'glossary',
+			items: [
+				{
+					term: 'Factor de Conversión',
+					definition: 'Número por el que se multiplican todos los ingredientes: Cantidad Deseada / Cantidad Original.',
+				},
+				{
+					term: 'Merma de Cocción',
+					definition: 'Pérdida de peso de un ingrediente por evaporación o pérdida de grasa. No escala de forma lineal.',
+				},
+				{
+					term: 'Peso Bruto vs Neto',
+					definition: 'El peso antes y después de limpiar el ingrediente. Escalamos siempre sobre el peso de la receta original.',
+				},
+				{
+					term: 'Rendimiento',
+					definition: 'Cantidad total de producto terminado tras el escalado y la cocción.',
+				},
+			],
+		},
+		{
+			type: 'tip',
+			title: 'El truco del Huevo Batido',
+			html: 'Si la calculadora indica 2.3 huevos, bate un huevo entero, pésalo y utiliza solo el porcentaje correspondiente (0.3). Es la única forma de mantener la precisión en repostería fina.',
+		},
+		{
+			type: 'paragraph',
+			html: 'Nuestra herramienta simplifica la matemática para que puedas dedicar tu energía a lo que realmente importa: la creatividad y el sabor.',
+		},
+	],
+
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'WebApplication',
+      name: 'Escalador de Ingredientes',
+      description: 'Escala recetas automáticamente según el número de raciones. Calcula las cantidades exactas de ingredientes multiplicando o reduciendo tu receta sin complicaciones.',
+      url: 'https://jjlmoya.es/utilidades/escalador-ingredientes',
+      applicationCategory: 'Utilities',
+      inLanguage: 'es-ES',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'EUR',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'Article',
+      headline: 'Escalador de Ingredientes - Ajusta tus Recetas Fácilmente',
+      description: 'Escala recetas automáticamente según el número de raciones. Calcula las cantidades exactas de ingredientes multiplicando o reduciendo tu receta sin complicaciones.',
+      author: {
+        '@type': 'Person',
+        name: 'jjlmoya',
+      },
+      inLanguage: 'es-ES',
+      isPartOf: {
+        '@type': 'WebSite',
+        name: 'Utilidades jjlmoya',
+        url: 'https://jjlmoya.es',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'BreadcrumbList',
+      itemListElement: [
+        {
+          '@type': 'ListItem',
+          position: 1,
+          name: 'Inicio',
+          item: 'https://jjlmoya.es',
+        },
+        {
+          '@type': 'ListItem',
+          position: 2,
+          name: 'Utilidades',
+          item: 'https://jjlmoya.es/utilidades',
+        },
+        {
+          '@type': 'ListItem',
+          position: 3,
+          name: 'Cocina',
+          item: 'https://jjlmoya.es/utilidades/cocina',
+        },
+        {
+          '@type': 'ListItem',
+          position: 4,
+          name: 'Escalador de Ingredientes',
+          item: 'https://jjlmoya.es/utilidades/escalador-ingredientes',
+        },
+      ],
+    },
+  ],
+};

package/src/tool/ingredient-rescaler/i18n/fr.ts

@@ -0,0 +1,207 @@
+import type { ToolLocaleContent } from "../../../types";
+
+export const content: ToolLocaleContent = {
+  slug: "calculateur-mise-echelle-recette-ingredients-portions",
+  title: "Convertisseur de Portions et Ingrédients Professionnel",
+  description:
+    "Mettez à l'échelle vos recettes automatiquement selon le nombre de portions. Calculez les quantités exactes d'ingrédients avec une précision professionnelle.",
+  ui: {
+    servings: "Portions",
+    original: "Original",
+    desired: "Souhaité",
+    multiplyingFactor: "Facteur de Conversion",
+    ingredientsList: "Liste des Ingrédients",
+    pasteHere: "Collez votre liste d'ingrédients ici.",
+    exampleLine1: "Ex :",
+    exampleLine2: "500g Farine",
+    exampleLine3: "300ml Eau",
+    exampleLine4: "10g Sel",
+    result: "Résultat",
+    copy: "Copier",
+    copied: "Copié !",
+    emptyState: "Vos ingrédients ajustés apparaîtront ici...",
+    defaultIngredient1: "200g Farine",
+    defaultIngredient2: "100ml Lait",
+    defaultIngredient3: "2 Œufs",
+  },
+  faqTitle: "Questions Fréquentes sur l'Échelle des Recettes",
+  faq: [
+    {
+      question: "Pourquoi mon facteur de conversion inclut-il des décimales ?",
+      answer:
+        "Parce que les proportions culinaires ne tombent pas toujours sur des chiffres ronds. Si vous passez d'une recette pour 4 à 7 personnes, le facteur est exactement 1,75. Multiplier par ce ratio précis est plus sûr que d'arrondir arbitrairement.",
+    },
+    {
+      question: "Comment gérer les fractions comme '1/2 cac de sel' ?",
+      answer:
+        "Notre outil reconnaît automatiquement les chiffres. Il lira '1/2' comme '0,5' et l'adaptera. Pour plus de clarté, vous pouvez aussi saisir directement des décimales.",
+    },
+    {
+      question: "Dois-je arrondir les résultats finaux ?",
+      answer:
+        "Cela dépend de l'ingrédient. Pour les farines et liquides, oui. Pour les épices fortes ou la levure, nous recommandons de ne monter qu'à 75% du total calculé pour éviter de saturer le plat.",
+    },
+    {
+      question: "L'outil fonctionne-t-il avec les onces ou les tasses ?",
+      answer:
+        "Oui, l'outil multiplie n'importe quelle valeur numérique. Cependant, nous conseillons vivement de convertir en grammes pour une précision professionnelle sur de gros volumes.",
+    },
+  ],
+  howTo: [
+    {
+      name: "Entrez le nombre de portions",
+      text: "Définissez le nombre de personnes prévu initialement dans la recette, et le nombre pour lequel vous souhaitez cuisiner.",
+    },
+    {
+      name: "Collez votre liste d'ingrédients",
+      text: "Copiez et collez l'intégralité de votre liste. L'outil reconnaît les chiffres en début de ligne (ex: 500g, 1/2, 2.5) et les convertit instantanément.",
+    },
+    {
+      name: "Appliquez les ajustements de chef",
+      text: "Le calcul est exact, mais la cuisine est intuitive. Réduisez les épices à 75%. Ne multipliez jamais les temps de cuisson par le même facteur.",
+    },
+  ],
+  bibliographyTitle: "Bibliographie et Ressources Professionnelles",
+  bibliography: [
+    {
+      name: "Harold McGee - On Food and Cooking",
+      url: "https://en.wikipedia.org/wiki/Harold_McGee",
+    },
+    {
+      name: "The Flavor Bible - Page & Dornenburg",
+      url: "https://www.flavorprints.com/",
+    },
+    {
+      name: "Modernist Cuisine - Techniques de mise à l'échelle",
+      url: "https://www.modernistcuisine.com/",
+    },
+  ],
+  seo: [
+    {
+      type: "title",
+      text: "Guide Maître pour la Mise à l'Échelle et la Conversion de Recettes",
+      level: 2,
+    },
+    {
+      type: "paragraph",
+      html: "Le <strong>calcul des proportions</strong> est l'une des tâches les plus critiques en cuisine professionnelle. Il ne s'agit pas seulement de mathématiques, mais de comprendre comment la chimie des aliments réagit aux changements de volume.",
+    },
+    {
+      type: "stats",
+      columns: 4,
+      items: [
+        {
+          value: "x1.75",
+          label: "Facteur de 4 à 7 pers.",
+          icon: "mdi:calculator",
+        },
+        {
+          value: "75%",
+          label: "Ajustement Épices",
+          icon: "mdi:shaker-outline",
+        },
+        {
+          value: "0%",
+          label: "Échelle de Temps",
+          icon: "mdi:timer-off",
+        },
+        {
+          value: "100g",
+          label: "Base de Référence",
+          icon: "mdi:weight-gram",
+        },
+      ],
+    },
+    {
+      type: "title",
+      text: "Différences entre Échelle Linéaire et Contextuelle",
+      level: 3,
+    },
+    {
+      type: "comparative",
+      columns: 2,
+      items: [
+        {
+          title: "Mise à l'Échelle Linéaire",
+          icon: "mdi:math-log",
+          description: "Multiplication directe de toutes les valeurs par le facteur de conversion calculé.",
+          points: [
+            "Parfait pour la farine et les liquides de base",
+            "Idéal pour la pâtisserie froide de précision",
+            "Fonctionne bien pour les petits changements (x2, x0.5)",
+            "Facile à calculer automatiquement",
+          ],
+        },
+        {
+          title: "Mise à l'Échelle Contextuelle",
+          icon: "mdi:chef-hat",
+          description: "Ajustement des proportions basé sur la saturation des saveurs et l'évaporation.",
+          highlight: true,
+          points: [
+            "Évite l'excès de sel et d'épices",
+            "Prend en compte la surface d'évaporation",
+            "Ajuste la levure selon la chaleur de friction",
+            "Demande un jugement culinaire professionnel",
+          ],
+        },
+      ],
+    },
+    {
+      type: "title",
+      text: "Facteurs de Conversion Courants par Portion",
+      level: 3,
+    },
+    {
+      type: "table",
+      headers: ["Portions Origine", "Portions Cibles", "Facteur (FC)", "Difficulté"],
+      rows: [
+        ["2 personnes", "4 personnes", "x 2.0", "Faible (Linéaire)"],
+        ["4 personnes", "6 personnes", "x 1.5", "Faible (Linéaire)"],
+        ["4 personnes", "10 personnes", "x 2.5", "Moyenne (Vigilance épices)"],
+        ["4 personnes", "25 personnes", "x 6.25", "Haute (Contextuelle)"],
+      ],
+    },
+    {
+      type: "diagnostic",
+      variant: "warning",
+      title: "Erreurs Classiques en Doublant une Recette",
+      html: "Si vous remarquez que le goût est trop intense après conversion—surtout pour le piment ou le sel—réduisez l'échelle de ces ingrédients spécifiques à 75%. Ne doublez jamais le temps de cuisson ; la température interne dépend de l'épaisseur de la pièce.",
+    },
+    {
+      type: "title",
+      text: "Glossaire de la Standardisation Culinaire",
+      level: 3,
+    },
+    {
+      type: "glossary",
+      items: [
+        {
+          term: "Facteur de Conversion",
+          definition: "Chiffre multiplicateur : Quantité Souhaitée / Quantité Originale.",
+        },
+        {
+          term: "Ratio de Perte",
+          definition: "Perte de poids liée à l'évaporation ou au gras. Ne suit pas une courbe linéaire.",
+        },
+        {
+          term: "Poids Brut vs Net",
+          definition: "Poids avant et après parage. On convertit toujours sur la base du poids net de la recette.",
+        },
+        {
+          term: "Rendement de Production",
+          definition: "Quantité totale de produit fini après mise à l'échelle et cuisson.",
+        },
+      ],
+    },
+    {
+      type: "tip",
+      title: "L'Astuce de l'Œuf Battu",
+      html: "Si le calculateur demande 2,3 œufs, battez un œuf entier, pesez-le et n'utilisez que 30% du poids. C'est la seule façon de rester précis en pâtisserie fine.",
+    },
+    {
+      type: "paragraph",
+      html: "Notre outil simplifie les calculs pour vous permettre de vous concentrer sur l'essentiel : la créativité et le goût.",
+    },
+  ],
+  schemas: [],
+};

package/src/tool/ingredient-rescaler/index.ts

@@ -0,0 +1,24 @@
+import type { CookingToolEntry, ToolDefinition } from '../../types';
+import IngredientRescalerComponent from './component.astro';
+import IngredientRescalerSEO from './seo.astro';
+import IngredientRescalerBibliography from './bibliography.astro';
+
+export const ingredientRescaler: CookingToolEntry = {
+	id: 'ingredient-rescaler',
+	icons: {
+		bg: 'mdi:pot-steam',
+		fg: 'mdi:chef-hat',
+	},
+	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 const INGREDIENT_RESCALER_TOOL: ToolDefinition = {
+	entry: ingredientRescaler,
+	Component: IngredientRescalerComponent,
+	SEOComponent: IngredientRescalerSEO,
+	BibliographyComponent: IngredientRescalerBibliography,
+};

package/src/tool/ingredient-rescaler/init.ts

@@ -0,0 +1,200 @@
+type ParsedLine = {
+	original: string;
+	amount: number | null;
+	unit: string | null;
+	ingredient: string;
+	prefix: string;
+};
+
+interface IngredientRescalerUI {
+	copy: string;
+	copied: string;
+	emptyState: string;
+}
+
+const NUMBER_REGEX = /(\d+[\.,]\d+|\d+\/\d+|\d+)/;
+
+function parseLine(line: string): ParsedLine {
+	const cleanLine = line.trim();
+	if (!cleanLine) return { original: line, amount: null, unit: null, ingredient: '', prefix: '' };
+
+	const match = cleanLine.match(NUMBER_REGEX);
+
+	if (!match) {
+		return { original: line, amount: null, unit: null, ingredient: cleanLine, prefix: '' };
+	}
+
+	const numberStr = match[0];
+	const index = match.index || 0;
+
+	const prefix = cleanLine.substring(0, index);
+	const rest = cleanLine.substring(index + numberStr.length);
+
+	let amount = 0;
+	if (numberStr.includes('/')) {
+		const [num, den] = numberStr.split('/');
+		if (parseFloat(den) !== 0) {
+			amount = parseFloat(num) / parseFloat(den);
+		} else {
+			amount = parseFloat(num);
+		}
+	} else {
+		amount = parseFloat(numberStr.replace(',', '.'));
+	}
+
+	return {
+		original: line,
+		amount,
+		unit: null,
+		ingredient: rest,
+		prefix,
+	};
+}
+
+function formatAmount(amount: number): string {
+	if (Number.isInteger(amount)) return amount.toString();
+	const rounded = Math.round(amount * 100) / 100;
+	return rounded.toString().replace('.', ',');
+}
+
+function renderEmptyState(resultsContainer: HTMLDivElement, emptyStateText: string): void {
+	resultsContainer.innerHTML = `<div class="ir-empty-state"><span class="ir-empty-icon"></span><p>${emptyStateText}</p></div>`;
+}
+
+function renderResult(resultsContainer: HTMLDivElement, lines: string[], ratio: number): void {
+	lines.forEach((line) => {
+		const parsed = parseLine(line);
+
+		if (parsed.amount !== null) {
+			const newAmount = parsed.amount * ratio;
+			const formatted = formatAmount(newAmount);
+
+			const row = document.createElement('div');
+			row.className = 'ir-result-row';
+			row.innerHTML = `
+				<span class="ir-original-amount">${parsed.original}</span>
+				<span class="ir-new-amount">
+					${parsed.prefix}<span class="ir-new-value">${formatted}</span>${parsed.ingredient}
+				</span>
+			 `;
+			resultsContainer.appendChild(row);
+		} else if (line.trim()) {
+			const row = document.createElement('div');
+			row.className = 'ir-no-amount-row';
+			row.textContent = line;
+			resultsContainer.appendChild(row);
+		}
+	});
+}
+
+interface RescalerInputs {
+	originalInput: HTMLInputElement;
+	targetInput: HTMLInputElement;
+	ingredientsInput: HTMLTextAreaElement;
+}
+
+function getCopyLines(inputs: RescalerInputs): string[] {
+	const lines: string[] = [];
+	const original = parseFloat(inputs.originalInput.value) || 1;
+	const target = parseFloat(inputs.targetInput.value) || 1;
+	const ratio = original > 0 ? target / original : 1;
+
+	inputs.ingredientsInput.value.split('\n').forEach((line) => {
+		const parsed = parseLine(line);
+		if (parsed.amount !== null) {
+			const newAmount = parsed.amount * ratio;
+			lines.push(`${parsed.prefix}${formatAmount(newAmount)}${parsed.ingredient}`);
+		} else {
+			lines.push(line);
+		}
+	});
+
+	return lines;
+}
+
+function updateButtonState(copyBtn: HTMLButtonElement, copied: boolean, copiedText: string): void {
+	if (copied) {
+		copyBtn.textContent = copiedText;
+		copyBtn.classList.add('ir-copied');
+		copyBtn.classList.remove('ir-default');
+	} else {
+		copyBtn.classList.remove('ir-copied');
+		copyBtn.classList.add('ir-default');
+	}
+}
+
+function setupCopyButton(copyBtn: HTMLButtonElement, inputs: RescalerInputs, copiedText: string): void {
+	copyBtn.addEventListener('click', () => {
+		const lines = getCopyLines(inputs);
+		const originalText = copyBtn.innerHTML;
+
+		navigator.clipboard.writeText(lines.join('\n')).then(() => {
+			updateButtonState(copyBtn, true, copiedText);
+			setTimeout(() => {
+				copyBtn.innerHTML = originalText;
+				updateButtonState(copyBtn, false, copiedText);
+			}, 2000);
+		});
+	});
+}
+
+interface UpdateContext {
+	originalInput: HTMLInputElement;
+	targetInput: HTMLInputElement;
+	ingredientsInput: HTMLTextAreaElement;
+	multiplierDisplay: HTMLSpanElement;
+	resultsContainer: HTMLDivElement;
+	emptyStateText: string;
+}
+
+function createUpdateFunction(ctx: UpdateContext): () => void {
+	return () => {
+		const original = parseFloat(ctx.originalInput.value) || 1;
+		const target = parseFloat(ctx.targetInput.value) || 1;
+		const ratio = original > 0 ? target / original : 1;
+
+		ctx.multiplierDisplay.textContent = `${ratio.toFixed(2).replace('.', ',')}x`;
+		ctx.resultsContainer.innerHTML = '';
+
+		const text = ctx.ingredientsInput.value;
+		if (!text.trim()) {
+			renderEmptyState(ctx.resultsContainer, ctx.emptyStateText);
+			return;
+		}
+
+		renderResult(ctx.resultsContainer, text.split('\n'), ratio);
+	};
+}
+
+export function initIngredientRescaler(ui: IngredientRescalerUI & Record<string, string>): void {
+	const originalInput = document.getElementById('original-servings') as HTMLInputElement | null;
+	const targetInput = document.getElementById('target-servings') as HTMLInputElement | null;
+	const ingredientsInput = document.getElementById('ingredients-input') as HTMLTextAreaElement | null;
+	const multiplierDisplay = document.getElementById('multiplier-display') as HTMLSpanElement | null;
+	const resultsContainer = document.getElementById('results-container') as HTMLDivElement | null;
+	const copyBtn = document.getElementById('copy-btn') as HTMLButtonElement | null;
+
+	if (!originalInput || !targetInput || !ingredientsInput || !multiplierDisplay || !resultsContainer || !copyBtn) {
+		return;
+	}
+
+	const update = createUpdateFunction({
+		originalInput,
+		targetInput,
+		ingredientsInput,
+		multiplierDisplay,
+		resultsContainer,
+		emptyStateText: ui.emptyState,
+	});
+
+	originalInput.addEventListener('input', update);
+	targetInput.addEventListener('input', update);
+	ingredientsInput.addEventListener('input', update);
+
+	if (!ingredientsInput.value.trim()) {
+		ingredientsInput.value = `${ui.defaultIngredient1}\n${ui.defaultIngredient2}\n${ui.defaultIngredient3}`;
+	}
+
+	update();
+	setupCopyButton(copyBtn, { originalInput, targetInput, ingredientsInput }, ui.copied);
+}