@jjlmoya/utils-diy 1.1.0

package/src/tool/cutOptimizer/i18n/en.ts

@@ -0,0 +1,178 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CutOptimizerUI } from '../ui';
+
+const slug = 'cut-optimizer';
+const title = '1D and 2D Cut Optimizer: Minimize Material Waste for Wood and Metal';
+const description =
+  'Free cut optimizer for wood, metal, and pipes. Calculate the most efficient cutting plan using the Best Fit Decreasing algorithm. Supports 1D linear and 2D panel optimization with kerf compensation.';
+
+const faqData = [
+  {
+    question: 'What is a 1D cut optimizer?',
+    answer:
+      'A 1D cut optimizer uses the Bin Packing algorithm to determine how to cut smaller pieces from standard-length stock material (timber, metal profiles, pipes) with minimum waste. It solves the Cutting Stock Problem computationally in milliseconds.',
+  },
+  {
+    question: 'Why does kerf width matter in cut planning?',
+    answer:
+      'Every saw cut consumes material equal to the blade thickness (kerf). A standard table saw removes 3mm per cut. On a project with 10 cuts, that is 30mm of lost material. Ignoring kerf means your last pieces will be shorter than planned.',
+  },
+  {
+    question: 'What is the difference between 1D and 2D cut optimization?',
+    answer:
+      '1D optimization handles linear material (boards, bars, pipes) by optimizing length only. 2D optimization handles sheet material (plywood, MDF, glass) by fitting rectangular pieces onto a larger sheet, optimizing both dimensions simultaneously.',
+  },
+  {
+    question: 'How do I save my cut plan?',
+    answer:
+      'Print the page or take a screenshot of the visual cut diagram to use as a physical guide in your workshop. Annotate each bar with its number to follow the sequence without mistakes.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Define the stock material',
+    text: 'Enter the total length (and width for panels) of the stock material you have available.',
+  },
+  {
+    name: 'Set the kerf width',
+    text: 'Adjust the blade thickness in millimetres so the calculation accounts for material lost per cut.',
+  },
+  {
+    name: 'List the required pieces',
+    text: 'Enter the length and quantity of each piece needed for your project.',
+  },
+  {
+    name: 'Run the optimization',
+    text: 'Get the most efficient cut layout and the exact waste percentage generated.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'Technical References',
+  bibliography: [
+    {
+      name: 'Cutting Stock Problem: Wikipedia',
+      url: 'https://en.wikipedia.org/wiki/Cutting_stock_problem',
+    },
+    {
+      name: 'Bin Packing Problem: Wolfram MathWorld',
+      url: 'https://mathworld.wolfram.com/BinPackingProblem.html',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'The Complete Guide to Cut Optimization',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Cut optimization — technically known as the <strong>Cutting Stock Problem</strong> — is one of the most practically useful problems in combinatorial mathematics. For a project with 20 pieces and 5 bars of stock, there are millions of possible arrangements. A computational algorithm finds the near-optimal solution in milliseconds, reducing typical 15% material waste to under 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Linear 1D vs Panel 2D Optimization',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Linear Optimization for Bars and Profiles',
+      html: '<p><strong>Linear (1D) optimization</strong> handles material that is optimized by length alone: timber, aluminium profiles, steel sections, copper pipe, and threaded rod. The algorithm packs all required pieces onto the minimum number of stock lengths, accounting for saw kerf at every cut.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Panel Optimization for Sheet Materials',
+      html: '<p><strong>Panel (2D) optimization</strong> handles sheet materials such as plywood, MDF, chipboard, glass, acrylic, and sheet metal. It uses a guillotine-cut algorithm, meaning every cut runs edge to edge — matching how table saws and panel saws actually operate.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Understanding Kerf: The Hidden Material Loss',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'The <strong>kerf</strong> is the width of material removed by the blade per cut. A standard table saw blade removes 3.0 to 3.2mm per pass. A circular hand saw removes 1.5 to 2.5mm. A laser cutter removes just 0.1 to 0.3mm. On a project with 10 cuts from a 2400mm board, a 3mm kerf costs you 30mm of usable material — enough to lose a whole small piece.',
+    },
+    {
+      type: 'title',
+      text: 'The Best Fit Decreasing Algorithm',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'How the Optimizer Works Under the Hood',
+      html: '<p>The core algorithm uses the <strong>Best Fit Decreasing (BFD)</strong> strategy: pieces are sorted from largest to smallest, since large pieces are hardest to fit. For each piece, the algorithm scans all existing offcuts and places it in the one that leaves the least remaining space. Only when no existing offcut can accommodate the piece is a new stock bar opened. This approach typically achieves 95% or better material efficiency.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Linear (Bars)',
+    modePanelLabel: 'Panel (Sheets)',
+    configTitle: 'Material Configuration',
+    labelStockLength: 'Stock Length (mm)',
+    labelStockWidth: 'Stock Width (mm)',
+    labelKerf: 'Blade Kerf (mm)',
+    cutsTitle: 'Cut List',
+    placeholderLength: 'Length',
+    placeholderWidth: 'Width',
+    placeholderQty: 'Qty',
+    btnRemoveTitle: 'Remove',
+    statStockUsed: 'Stock Used',
+    statTotalCuts: 'Total Cuts',
+    statWaste: 'Total Waste',
+    statEfficiency: 'Efficiency',
+    vizTitle: 'Cut Visualization',
+    emptyState: 'Add cuts and run the optimizer to see the cut plan.',
+    noValidCuts: 'Could not generate valid cuts. Check your measurements.',
+    noValidPanels: 'Could not generate valid panels. Check that pieces fit within the sheet.',
+    stockLabel: 'Stock',
+    panelLabel: 'Panel',
+    wasteLabel: 'Waste:',
+    effLabel: 'Eff:',
+  },
+};

package/src/tool/cutOptimizer/i18n/es.ts

@@ -0,0 +1,178 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CutOptimizerUI } from '../ui';
+
+const slug = 'optimizador-corte';
+const title = 'Optimizador de Cortes de Listones y Tableros';
+const description =
+  'Calculadora gratuita para optimizar cortes en madera, metal o tuberías. Minimiza el desperdicio con algoritmo de Bin Packing 1D y 2D. Ideal para carpintería, metalurgia y reformas.';
+
+const faqData = [
+  {
+    question: '¿Qué es un optimizador de corte 1D?',
+    answer:
+      'Es una herramienta que usa algoritmos matemáticos (como el Bin Packing Problem) para determinar cómo cortar piezas más pequeñas de una pieza larga estándar (listón, perfil, tubería) con el mínimo desperdicio posible.',
+  },
+  {
+    question: '¿Por qué incluir el grosor del corte (Kerf)?',
+    answer:
+      'Cada vez que la sierra corta el material, se consume unos milímetros (normalmente entre 2mm y 4mm según el disco). Si no calculas este espacio, las últimas piezas de tu lista quedarán más cortas de lo planeado.',
+  },
+  {
+    question: '¿Puedo mezclar piezas de diferentes longitudes?',
+    answer:
+      'Sí, nuestra calculadora acepta cualquier combinación de longitudes y cantidades. El algoritmo evaluará todas las combinaciones posibles y priorizará el aprovechamiento máximo del material de stock.',
+  },
+  {
+    question: '¿Cómo guardo mi plan de corte?',
+    answer:
+      'Una vez optimizado, puedes imprimir la página o hacer una captura de pantalla del esquema visual. Esto te servirá de guía física en el taller para no confundir el orden de los cortes.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Definir el material base (Stock)',
+    text: 'Introduce la longitud total del listón o perfil disponible (ej. 2400mm o 6000mm).',
+  },
+  {
+    name: 'Configurar el grosor del disco (Kerf)',
+    text: 'Ajusta los milímetros que la sierra elimina en cada paso para que el cálculo sea milimétrico.',
+  },
+  {
+    name: 'Listar las piezas deseadas',
+    text: 'Escribe la longitud y cantidad de cada pieza que necesitas para tu proyecto.',
+  },
+  {
+    name: 'Ejecutar la optimización',
+    text: 'Obtén el esquema de corte más eficiente y el porcentaje exacto de desperdicio generado.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'es',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Referencias Técnicas',
+  bibliography: [
+    {
+      name: 'Cutting Stock Problem: Wikipedia',
+      url: 'https://en.wikipedia.org/wiki/Cutting_stock_problem',
+    },
+    {
+      name: 'Bin Packing Problem: Wolfram MathWorld',
+      url: 'https://mathworld.wolfram.com/BinPackingProblem.html',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Guía Definitiva de Optimización de Corte',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'La optimización de corte, conocida técnicamente como el <strong>Problema de Corte de Stock</strong>, es uno de los desafíos logísticos más fascinantes en la ingeniería industrial. Para un proyecto con 20 piezas y 5 barras de stock, existen millones de combinaciones posibles. Un algoritmo computacional puede encontrar la solución óptima en milisegundos, reduciendo el desperdicio habitual del 15% a menos del 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Corte Lineal 1D y Corte de Panel 2D',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Corte Lineal para Listones y Perfiles',
+      html: '<p>En el <strong>corte lineal (1D)</strong>, la optimización ocurre en una sola dimensión: la longitud. El ancho del material se asume constante. Es ideal para madera dimensional (listones, vigas), perfilería metálica y de aluminio, tuberías de PVC o cobre, y varillas roscadas.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Corte de Panel para Tableros y Chapas',
+      html: '<p>En el <strong>corte de panel (2D)</strong>, se gestionan dos dimensiones: ancho y largo. La herramienta utiliza algoritmos tipo guillotina, donde cada corte va de borde a borde. Ideal para tableros derivados (MDF, aglomerado), contrachapado, vidrio, metacrilato y chapas metálicas.</p>',
+    },
+    {
+      type: 'title',
+      text: 'El Factor Crítico: El Grosor del Corte (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'El <strong>Kerf</strong> es el material que se elimina en cada corte. Un disco de sierra estándar de mesa consume entre 3,0mm y 3,2mm por corte. Una sierra circular de mano consume 1,5 a 2,5mm. Un corte láser en metacrilato apenas 0,1 a 0,3mm. Ignorar el kerf en un proyecto con 10 cortes en listones de 2400mm puede hacerte perder entre 30mm y 32mm de material útil.',
+    },
+    {
+      type: 'title',
+      text: 'El Algoritmo Best Fit Decreasing',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Cómo Funciona el Optimizador por Dentro',
+      html: '<p>El núcleo del optimizador usa la estrategia <strong>Best Fit Decreasing (BFD)</strong>: primero ordena todas las piezas de mayor a menor longitud (las grandes son más difíciles de encajar). Luego, para cada pieza, busca el retal existente donde quepa dejando el menor sobrante posible. Solo si no cabe en ninguno, abre una nueva barra virgen. Este proceso reduce el desperdicio en un orden de magnitud respecto a la selección aleatoria.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Lineal (Barras)',
+    modePanelLabel: 'Panel (Tableros)',
+    configTitle: 'Configuración Material',
+    labelStockLength: 'Largo del Material (mm)',
+    labelStockWidth: 'Ancho del Material (mm)',
+    labelKerf: 'Grosor de Hoja / Kerf (mm)',
+    cutsTitle: 'Lista de Cortes',
+    placeholderLength: 'Largo',
+    placeholderWidth: 'Ancho',
+    placeholderQty: 'Cant.',
+    btnRemoveTitle: 'Eliminar',
+    statStockUsed: 'Material Usado',
+    statTotalCuts: 'Cortes Totales',
+    statWaste: 'Desperdicio Total',
+    statEfficiency: 'Eficiencia',
+    vizTitle: 'Visualización de Corte',
+    emptyState: 'Añade cortes y pulsa calcular para ver el plan de corte.',
+    noValidCuts: 'No se pudieron generar cortes válidos. Verifica las medidas.',
+    noValidPanels: 'No se pudieron generar paneles válidos. Verifica que las piezas quepan en el tablero.',
+    stockLabel: 'Material',
+    panelLabel: 'Panel',
+    wasteLabel: 'Desperdicio:',
+    effLabel: 'Efic:',
+  },
+};

package/src/tool/cutOptimizer/i18n/fr.ts

@@ -0,0 +1,178 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CutOptimizerUI } from '../ui';
+
+const slug = 'optimiseur-decoupe';
+const title = 'Optimiseur de Découpe 1D et 2D: Réduire les Chutes de Matériaux';
+const description =
+  "Optimiseur de découpe gratuit pour bois, métal et tubes. Calculez le plan de coupe le plus efficace avec l'algorithme Best Fit Decreasing. Supporte la découpe linéaire 1D et panneaux 2D avec compensation du trait de scie.";
+
+const faqData = [
+  {
+    question: "Qu'est-ce qu'un optimiseur de découpe 1D?",
+    answer:
+      "Un optimiseur de découpe 1D utilise l'algorithme de Bin Packing pour déterminer comment couper des pièces plus petites dans des longueurs standard (bois, profilés, tubes) avec un minimum de chutes. Il résout le problème de découpe de stock de manière informatique en quelques millisecondes.",
+  },
+  {
+    question: "Pourquoi le trait de scie (Kerf) est-il important?",
+    answer:
+      "Chaque passage de scie consomme du matériau égal à l'épaisseur de la lame. Une scie circulaire sur table standard enlève 3mm par coupe. Sur un projet avec 10 coupes, cela représente 30mm de matériau perdu. Ignorer le trait de scie signifie que vos dernières pièces seront plus courtes que prévu.",
+  },
+  {
+    question: "Quelle est la différence entre la découpe 1D et 2D?",
+    answer:
+      "La découpe 1D traite les matériaux linéaires (barres, profilés, tubes) en optimisant uniquement la longueur. La découpe 2D traite les panneaux (contreplaqué, MDF, verre) en ajustant des pièces rectangulaires sur un panneau plus grand, en optimisant les deux dimensions simultanément.",
+  },
+  {
+    question: "Comment sauvegarder mon plan de découpe?",
+    answer:
+      "Imprimez la page ou faites une capture d'écran du schéma visuel pour l'utiliser comme guide physique dans votre atelier. Annotez chaque barre avec son numéro pour suivre la séquence sans erreur.",
+  },
+];
+
+const howToData = [
+  {
+    name: 'Définir le matériau de base',
+    text: 'Saisissez la longueur totale (et la largeur pour les panneaux) du matériau de stock disponible.',
+  },
+  {
+    name: 'Configurer le trait de scie',
+    text: "Ajustez l'épaisseur de lame en millimètres pour que le calcul tienne compte du matériau perdu par coupe.",
+  },
+  {
+    name: 'Lister les pièces requises',
+    text: 'Saisissez la longueur et la quantité de chaque pièce nécessaire pour votre projet.',
+  },
+  {
+    name: "Lancer l'optimisation",
+    text: "Obtenez le plan de coupe le plus efficace et le pourcentage exact de chutes générées.",
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'fr',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Questions Fréquentes',
+  faq: faqData,
+  bibliographyTitle: 'Références Techniques',
+  bibliography: [
+    {
+      name: 'Problème de découpe de stock: Wikipedia',
+      url: 'https://en.wikipedia.org/wiki/Cutting_stock_problem',
+    },
+    {
+      name: 'Problème de bin packing: Wolfram MathWorld',
+      url: 'https://mathworld.wolfram.com/BinPackingProblem.html',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: "Guide Complet de l'Optimisation de Découpe",
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: "L'optimisation de découpe, connue techniquement sous le nom de <strong>Problème de Découpe de Stock</strong>, est l'un des défis logistiques les plus utiles en mathématiques combinatoires. Pour un projet avec 20 pièces et 5 barres de stock, il existe des millions de combinaisons possibles. Un algorithme informatique trouve la solution quasi optimale en quelques millisecondes, réduisant les chutes habituelles de 15% à moins de 5%.",
+    },
+    {
+      type: 'title',
+      text: 'Découpe Linéaire 1D et Découpe Panneau 2D',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Optimisation Linéaire pour Barres et Profilés',
+      html: "<p>La <strong>découpe linéaire (1D)</strong> traite les matériaux optimisés uniquement par leur longueur: bois dimensionnel, profilés aluminium, tubes PVC ou cuivre, et tiges filetées. L'algorithme dispose toutes les pièces requises sur le nombre minimum de longueurs de stock, en intégrant le trait de scie à chaque coupe.</p>",
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Optimisation Panneau pour Matériaux en Feuille',
+      html: "<p>La <strong>découpe panneau (2D)</strong> traite les matériaux en feuille tels que contreplaqué, MDF, verre, méthacrylate et tôle. Elle utilise un algorithme à coupe guillotine, où chaque coupe va d'un bord à l'autre, conformément au fonctionnement réel des scies circulaires et des scies de format.</p>",
+    },
+    {
+      type: 'title',
+      text: 'Le Trait de Scie: La Perte de Matériau Cachée',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: "Le <strong>trait de scie (Kerf)</strong> est la largeur de matériau enlevée par la lame à chaque coupe. Une scie circulaire sur table standard enlève 3,0 à 3,2mm par passage. Une scie circulaire portative enlève 1,5 à 2,5mm. Un laser enlève seulement 0,1 à 0,3mm. Sur un projet avec 10 coupes dans une planche de 2400mm, un kerf de 3mm représente 30mm de matériau utilisable perdu — de quoi rater une petite pièce entière.",
+    },
+    {
+      type: 'title',
+      text: "L'Algorithme Best Fit Decreasing",
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: "Fonctionnement Interne de l'Optimiseur",
+      html: "<p>Le cœur de l'algorithme utilise la stratégie <strong>Best Fit Decreasing (BFD)</strong>: les pièces sont triées de la plus grande à la plus petite, car les grandes pièces sont plus difficiles à placer. Pour chaque pièce, l'algorithme parcourt tous les chutes existantes et la place dans celle qui laisse le moins d'espace résiduel. Seulement si aucune chute existante ne peut accueillir la pièce, une nouvelle barre vierge est ouverte. Cette approche atteint généralement 95% d'efficacité matérielle ou plus.</p>",
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Linéaire (Barres)',
+    modePanelLabel: 'Panneau (Tableros)',
+    configTitle: 'Configuration Matériau',
+    labelStockLength: 'Longueur du matériau (mm)',
+    labelStockWidth: 'Largeur du matériau (mm)',
+    labelKerf: 'Trait de scie / Kerf (mm)',
+    cutsTitle: 'Liste de Découpes',
+    placeholderLength: 'Longueur',
+    placeholderWidth: 'Largeur',
+    placeholderQty: 'Qté',
+    btnRemoveTitle: 'Supprimer',
+    statStockUsed: 'Matériaux utilisés',
+    statTotalCuts: 'Coupes totales',
+    statWaste: 'Chutes totales',
+    statEfficiency: 'Efficacité',
+    vizTitle: 'Visualisation de Découpe',
+    emptyState: 'Ajoutez des coupes et lancez le calcul pour voir le plan de découpe.',
+    noValidCuts: 'Impossible de générer des coupes valides. Vérifiez les dimensions.',
+    noValidPanels: 'Impossible de générer des panneaux valides. Vérifiez que les pièces rentrent dans le panneau.',
+    stockLabel: 'Matériau',
+    panelLabel: 'Panneau',
+    wasteLabel: 'Chute:',
+    effLabel: 'Eff:',
+  },
+};

package/src/tool/cutOptimizer/index.ts

@@ -0,0 +1,28 @@
+import CutOptimizerComponent from './component.astro';
+import CutOptimizerSEO from './seo.astro';
+import CutOptimizerBibliography from './bibliography.astro';
+import type { DiyToolEntry, ToolDefinition } from '../../types';
+import type { CutOptimizerUI } from './ui';
+
+export {
+  CutOptimizerComponent,
+  CutOptimizerSEO,
+  CutOptimizerBibliography,
+};
+
+const es = async () => (await import('./i18n/es')).content;
+const en = async () => (await import('./i18n/en')).content;
+const fr = async () => (await import('./i18n/fr')).content;
+
+export const cutOptimizer: DiyToolEntry<CutOptimizerUI> = {
+  id: 'cut-optimizer',
+  icons: { bg: 'mdi:saw-blade', fg: 'mdi:ruler' },
+  i18n: { es, en, fr },
+};
+
+export const CUT_OPTIMIZER_TOOL: ToolDefinition = {
+  entry: cutOptimizer,
+  Component: CutOptimizerComponent,
+  SEOComponent: CutOptimizerSEO,
+  BibliographyComponent: CutOptimizerBibliography,
+};