@jjlmoya/utils-diy 1.2.0 → 1.4.0

package/src/tool/cutOptimizer/i18n/nl.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 = 'zaagplan-optimalisatie';
+const title = 'Zaagplan Optimalisatie voor Latten en Platen';
+const description =
+  'Gratis calculator voor het optimaliseren van zaagsneden in hout, metaal of buizen. Minimaliseer afval met 1D en 2D Bin Packing algoritmes. Ideaal voor houtbewerking en metaalbewerking.';
+
+const faqData = [
+  {
+    question: 'Wat is een 1D zaag-optimalisator?',
+    answer:
+      'Het is een tool die wiskundige algoritmes gebruikt (zoals het Bin Packing Problem) om te bepalen hoe je kleinere stukken kunt zagen uit een standaard lang stuk (lat, profiel, buis) met zo min mogelijk afval.',
+  },
+  {
+    question: 'Waarom moet ik de zaagsnededikte (Kerf) opgeven?',
+    answer:
+      'Elke keer dat de zaag door het materiaal gaat, verdwijnt er een paar millimeter (meestal tussen 2mm en 4mm afhankelijk van het blad). Als je deze ruimte niet meerekent, worden de laatste stukken op je lijst korter dan gepland.',
+  },
+  {
+    question: 'Kan ik stukken van verschillende lengtes mengen?',
+    answer:
+      'Ja, onze calculator accepteert elke combinatie van lengtes en aantallen. Het algoritme evalueert alle mogelijke combinaties en geeft prioriteit aan een maximale benutting van het voorraadmaterial.',
+  },
+  {
+    question: 'Hoe sla ik mijn zaagplan op?',
+    answer:
+      'Zodra het geoptimaliseerd is, kun je de pagina afdrukken of een screenshot maken van het visuele schema. Dit dient als fysieke gids in de werkplaats om de volgorde van de sneden niet te verwarren.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Basis materiaal definiëren (Stock)',
+    text: 'Voer de totale lengte van de beschikbare lat of profiel in (bijv. 2400mm of 6000mm).',
+  },
+  {
+    name: 'Zaagblad dikte instellen (Kerf)',
+    text: 'Stel de millimeters in die de zaag bij elke stap verwijdert, zodat de berekening tot op de millimeter nauwkeurig is.',
+  },
+  {
+    name: 'Gewenste stukken opgeven',
+    text: 'Schrijf de lengte en het aantal van elk stuk dat je nodig hebt voor je project.',
+  },
+  {
+    name: 'Optimalisatie uitvoeren',
+    text: 'Ontvang het meest efficiënte zaagschema en het exacte percentage gegenereerd afval.',
+  },
+];
+
+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: 'nl',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Veelgestelde Vragen',
+  faq: faqData,
+  bibliographyTitle: 'Technische Referenties',
+  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: 'Definitieve Gids voor Zaagplan Optimalisatie',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'De optimalisatie van zaagsneden, technisch bekend als het <strong>Cutting Stock Problem</strong>, is een van de meest fascinerende logistieke uitdagingen in de industriële techniek. Voor een project met 20 stukken en 5 voorraadstaven zijn er miljoenen mogelijke combinaties. Een computeralgoritme kan de optimale oplossing in milliseconden vinden, waardoor het gebruikelijke afval van 15% wordt gereduceerd tot minder dan 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Lineaire 1D snede en 2D Plaatsnede',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Lineaire snede voor Latten en Profielen',
+      html: '<p>Bij de <strong>lineaire snede (1D)</strong> vindt de optimalisatie plaats in slechts één dimensie: de lengte. De breedte van het materiaal wordt als constant verondersteld. Het is ideaal voor constructiehout (latten, balken), metalen en aluminium profielen, PVC of koperen buizen, en draadeinden.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Plaatsnede voor Planken en Platen',
+      html: '<p>Bij de <strong>plaatsnede (2D)</strong> worden twee dimensies beheerd: breedte en lengte. De tool gebruikt guillotine-algoritmes, waarbij elke snede van rand tot rand gaat. Ideaal voor afgeleide platen (MDF, spaanplaat), multiplex, glas, methacrylaat en metaalplaten.</p>',
+    },
+    {
+      type: 'title',
+      text: 'De Kritieke Factor: De Zaagsnededikte (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'De <strong>Kerf</strong> is het materiaal dat bij elke snede wordt verwijderd. Een standaard tafelzaagblad verbruikt tussen 3,0mm en 3,2mm per snede. Een handcirkelzaag verbruikt 1,5 tot 2,5mm. Een lasersnede in methacrylaat nauwelijks 0,1 tot 0,3mm. Het negeren van de kerf in een project met 10 sneden in latten van 2400mm kan ervoor zorgen dat je tussen de 30mm en 32mm aan bruikbaar materiaal verliest.',
+    },
+    {
+      type: 'title',
+      text: 'Het Best Fit Decreasing Algoritme',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Hoe de Optimalisator van binnen werkt',
+      html: '<p>De kern van de optimalisator gebruikt de <strong>Best Fit Decreasing (BFD)</strong> strategie: eerst worden alle stukken van groot naar klein gesorteerd (grote stukken zijn moeilijker passend te krijgen). Vervolgens wordt voor elk stuk gezocht naar het bestaande restant waar het in past met zo min mogelijk overschot. Alleen als het nergens in past, wordt een nieuwe staaf gebruikt. Dit proces vermindert afval met een orde van grootte vergeleken met willekeurige selectie.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Lineair (Staven)',
+    modePanelLabel: 'Paneel (Platen)',
+    configTitle: 'Materiaal Configuratie',
+    labelStockLength: 'Lengte Materiaal (mm)',
+    labelStockWidth: 'Breedte Materiaal (mm)',
+    labelKerf: 'Bladdikte / Kerf (mm)',
+    cutsTitle: 'Lijst met Sneden',
+    placeholderLength: 'Lengte',
+    placeholderWidth: 'Breedte',
+    placeholderQty: 'Aantal',
+    btnRemoveTitle: 'Verwijderen',
+    statStockUsed: 'Materiaal Gebruikt',
+    statTotalCuts: 'Totale Sneden',
+    statWaste: 'Totaal Afval',
+    statEfficiency: 'Efficiëntie',
+    vizTitle: 'Zaag Visualisatie',
+    emptyState: 'Voeg sneden toe en druk op berekenen om het zaagplan te zien.',
+    noValidCuts: 'Kon geen geldige sneden genereren. Controleer de maten.',
+    noValidPanels: 'Kon geen geldige panelen genereren. Controleer of de stukken op de plaat passen.',
+    stockLabel: 'Materiaal',
+    panelLabel: 'Paneel',
+    wasteLabel: 'Afval:',
+    effLabel: 'Eff:',
+  },
+};

package/src/tool/cutOptimizer/i18n/pl.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 = 'optymalizator-ciecia';
+const title = 'Optymalizator Cięcia Listew i Płyt';
+const description =
+  'Bezpłatny kalkulator optymalizacji cięcia drewna, metalu lub rur. Minimalizuj odpady dzięki algorytmom Bin Packing 1D i 2D. Idealny dla stolarstwa i metalurgii.';
+
+const faqData = [
+  {
+    question: 'Co to jest optymalizator cięcia 1D?',
+    answer:
+      'Jest to narzędzie wykorzystujące algorytmy matematyczne (takie jak problem pakowania w pojemniki - Bin Packing Problem), aby określić, jak wyciąć mniejsze elementy ze standardowego długiego elementu (listwa, profil, rura) przy minimalnym możliwym odpadzie.',
+  },
+  {
+    question: 'Dlaczego należy uwzględnić grubość rzazu (Kerf)?',
+    answer:
+      'Za każdym razem, gdy piła przecina materiał, zużywa się kilka milimetrów (zwykle od 2 do 4 mm w zależności od tarczy). Jeśli nie uwzględnisz tej przestrzeni, ostatnie elementy z Twojej listy będą krótsze niż planowano.',
+  },
+  {
+    question: 'Czy mogę mieszać elementy o różnych długościach?',
+    answer:
+      'Tak, nasz kalkulator akceptuje dowolną kombinację długości i ilości. Algorytm oceni wszystkie możliwe kombinacje i nada priorytet maksymalnemu wykorzystaniu materiału z magazynu.',
+  },
+  {
+    question: 'Jak zapisać mój plan cięcia?',
+    answer:
+      'Po zoptymalizowaniu możesz wydrukować stronę lub zrobić zrzut ekranu schematu wizualnego. Służy to jako fizyczny przewodnik w warsztacie, aby nie pomylić kolejności cięć.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Zdefiniuj materiał bazowy (Stock)',
+    text: 'Wprowadź całkowitą długość dostępnej listwy lub profilu (np. 2400 mm lub 6000 mm).',
+  },
+  {
+    name: 'Skonfiguruj grubość tarczy (Kerf)',
+    text: 'Ustaw milimetry, które piła usuwa przy każdym przejściu, aby obliczenie było co do milimetra dokładne.',
+  },
+  {
+    name: 'Wymień pożądane elementy',
+    text: 'Wpisz długość i ilość każdego elementu, którego potrzebujesz do swojego projektu.',
+  },
+  {
+    name: 'Uruchom optymalizację',
+    text: 'Uzyskaj najbardziej wydajny schemat cięcia i dokładny procent wygenerowanego odpadu.',
+  },
+];
+
+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: 'pl',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Często Zadawane Pytania',
+  faq: faqData,
+  bibliographyTitle: 'Referencje Techniczne',
+  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: 'Ostateczny Przewodnik Optymalizacji Cięcia',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Optymalizacja cięcia, technicznie znana jako <strong>Problem Cięcia Magazynowego (Cutting Stock Problem)</strong>, jest jednym z najciekawszych wyzwań logistycznych w inżynierii przemysłowej. Dla projektu z 20 elementami i 5 prętami magazynowymi istnieją miliony możliwych kombinacji. Algorytm komputerowy może znaleźć optymalne rozwiązanie w milisekundy, redukując typowy odpad z 15% do mniej niż 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Cięcie liniowe 1D i cięcie płyt 2D',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Cięcie liniowe dla listew i profili',
+      html: '<p>W <strong>cięciu liniowym (1D)</strong> optymalizacja zachodzi tylko w jednym wymiarze: długości. Szerokość materiału przyjmuje się jako stałą. Idealne dla tarcicy (listwy, belki), profili metalowych i aluminiowych, rur PVC lub miedzianych oraz prętów gwintowanych.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Cięcie płyt dla paneli i blach',
+      html: '<p>W <strong>cięciu płyt (2D)</strong> zarządza się dwoma wymiarami: szerokością i długością. Narzędzie wykorzystuje algorytmy typu gilotynowego, w których każde cięcie idzie od krawędzi do krawędzi. Idealne dla płyt drewnopochodnych (MDF, wiórowa), sklejki, szkła, pleksi i blach metalowych.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Czynnik krytyczny: Grubość rzazu (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: '<strong>Kerf</strong> to materiał usuwany przy każdym cięciu. Standardowa tarcza piły stołowej zużywa od 3,0 mm do 3,2 mm na cięcie. Ręczna piła tarczowa zużywa 1,5 do 2,5 mm. Cięcie laserowe w pleksi zaledwie 0,1 do 0,3 mm. Zignorowanie rzazu w projekcie z 10 cięciami na listwach o długości 2400 mm może spowodować utratę od 30 mm do 32 mm użytecznego materiału.',
+    },
+    {
+      type: 'title',
+      text: 'Algorytm Best Fit Decreasing',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Jak działa optymalizator od środka',
+      html: '<p>Rdzeń optymalizatora wykorzystuje strategię <strong>Best Fit Decreasing (BFD)</strong>: najpierw sortuje wszystkie elementy od największej do najmniejszej długości (duże elementy trudniej dopasować). Następnie dla każdego elementu szuka istniejącego odpadu, w którym się zmieści, pozostawiając jak najmniejszą resztę. Tylko jeśli nie mieści się w żadnym odpadzie, otwiera nowy pełny pręt. Ten proces redukuje odpady o rząd wielkości w stosunku do losowego wyboru.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Liniowy (Pręty)',
+    modePanelLabel: 'Panelowy (Płyty)',
+    configTitle: 'Konfiguracja Materiału',
+    labelStockLength: 'Długość Materiału (mm)',
+    labelStockWidth: 'Szerokość Materiał (mm)',
+    labelKerf: 'Grubość Tarczy / Kerf (mm)',
+    cutsTitle: 'Lista Cięć',
+    placeholderLength: 'Długość',
+    placeholderWidth: 'Szerokość',
+    placeholderQty: 'Ilość',
+    btnRemoveTitle: 'Usuń',
+    statStockUsed: 'Użyty Materiał',
+    statTotalCuts: 'Całkowite Cięcia',
+    statWaste: 'Całkowity Odpad',
+    statEfficiency: 'Wydajność',
+    vizTitle: 'Wizualizacja Cięcia',
+    emptyState: 'Dodaj cięcia i naciśnij oblicz, aby zobaczyć plan cięcia.',
+    noValidCuts: 'Nie udało się wygenerować prawidłowych cięć. Sprawdź wymiary.',
+    noValidPanels: 'Nie udało się wygenerować prawidłowych płyt. Sprawdź, czy elementy mieszczą się na płycie.',
+    stockLabel: 'Materiał',
+    panelLabel: 'Panel',
+    wasteLabel: 'Odpad:',
+    effLabel: 'Wydaj:',
+  },
+};

package/src/tool/cutOptimizer/i18n/pt.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 = 'otimizador-corte';
+const title = 'Otimizador de Cortes de Ripas e Painéis';
+const description =
+  'Calculadora gratuita para otimizar cortes em madeira, metal ou tubagens. Minimize o desperdício com o algoritmo Bin Packing 1D e 2D. Ideal para carpintaria, serralharia e reformas.';
+
+const faqData = [
+  {
+    question: 'O que é um otimizador de corte 1D?',
+    answer:
+      'É uma ferramenta que utiliza algoritmos matemáticos (como o Bin Packing Problem) para determinar como cortar peças mais pequenas de uma peça longa padrão (ripa, perfil, tubo) com o mínimo desperdício possível.',
+  },
+  {
+    question: 'Por que incluir a espessura do corte (Kerf)?',
+    answer:
+      'Cada vez que a serra corta o material, são consumidos alguns milímetros (normalmente entre 2mm e 4mm conforme o disco). Se não calcular este espaço, as últimas peças da sua lista ficarão mais curtas do que o planeado.',
+  },
+  {
+    question: 'Posso misturar peças de diferentes comprimentos?',
+    answer:
+      'Sim, a nossa calculadora aceita qualquer combinação de comprimentos e quantidades. O algoritmo avaliará todas as combinações possíveis e priorizará o aproveitamento máximo do material de stock.',
+  },
+  {
+    question: 'Como guardo o meu plano de corte?',
+    answer:
+      'Uma vez otimizado, pode imprimir a página ou fazer uma captura de ecrã do esquema visual. Isto servirá de guia físico na oficina para não confundir a ordem dos cortes.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Definir o material base (Stock)',
+    text: 'Introduza o comprimento total da ripa ou perfil disponível (ex. 2400mm ou 6000mm).',
+  },
+  {
+    name: 'Configurar a espessura do disco (Kerf)',
+    text: 'Ajuste os milímetros que a serra remove em cada passo para que o cálculo seja milimétrico.',
+  },
+  {
+    name: 'Listar as peças desejadas',
+    text: 'Escreva o comprimento e quantidade de cada peça de que necessita para o seu projeto.',
+  },
+  {
+    name: 'Executar a otimização',
+    text: 'Obtenha o esquema de corte mais eficiente e a percentagem exata de desperdício gerado.',
+  },
+];
+
+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: 'pt',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Perguntas Frequentes',
+  faq: faqData,
+  bibliographyTitle: 'Referências 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: 'Guia Definitiva de Otimização de Corte',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'La otimização de corte, conhecida tecnicamente como o <strong>Problema de Corte de Stock</strong>, é um dos desafios logísticos mais fascinantes na engenharia industrial. Para um projeto com 20 peças e 5 barras de stock, existem milhões de combinações possíveis. Um algoritmo computacional pode encontrar a solução ótima em milisegundos, reduzindo o desperdício habitual de 15% para menos de 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Corte Linear 1D e Corte de Painel 2D',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Corte Linear para Ripas e Perfis',
+      html: '<p>No <strong>corte linear (1D)</strong>, a otimização ocorre apenas numa dimensão: o comprimento. A largura do material é assumida constante. É ideal para madeira dimensional (ripas, vigas), perfis metálicos e de alumínio, tubagens de PVC ou cobre, e varões roscados.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Corte de Painel para Placas e Chapas',
+      html: '<p>No <strong>corte de painel (2D)</strong>, gerem-se duas dimensões: largura e comprimento. A ferramenta utiliza algoritmos tipo guilhotina, onde cada corte vai de borda a borda. Ideal para painéis derivados (MDF, aglomerado), contraplacado, vidro, metacrilato e chapas metálicas.</p>',
+    },
+    {
+      type: 'title',
+      text: 'O Factor Crítico: A Espessura do Corte (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'O <strong>Kerf</strong> é o material que se remove em cada corte. Um disco de serra padrão de mesa consome entre 3,0mm e 3,2mm por corte. Uma serra circular de mão consome 1,5 a 2,5mm. Um corte laser em metacrilato apenas 0,1 a 0,3mm. Ignorar o kerf num projeto com 10 cortes em ripas de 2400mm pode fazer com que perca entre 30mm e 32mm de material útil.',
+    },
+    {
+      type: 'title',
+      text: 'O Algoritmo Best Fit Decreasing',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Como Funciona o Otimizador por Dentro',
+      html: '<p>O núcleo do otimizador usa a estratégia <strong>Best Fit Decreasing (BFD)</strong>: primeiro ordena todas as peças do maior ao menor comprimento (as grandes são mais difíceis de encaixar). Depois, para cada peça, procura a sobra existente onde caiba deixando o menor excedente possível. Só se não couber em nenhuma, abre uma nova barra virgem. Este processo reduz o desperdício numa ordem de magnitude em relação à seleção aleatória.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Linear (Barras)',
+    modePanelLabel: 'Painel (Placas)',
+    configTitle: 'Configuração Material',
+    labelStockLength: 'Comprimento do Material (mm)',
+    labelStockWidth: 'Largura do Material (mm)',
+    labelKerf: 'Espessura da Folha / Kerf (mm)',
+    cutsTitle: 'Lista de Cortes',
+    placeholderLength: 'Compr.',
+    placeholderWidth: 'Largura',
+    placeholderQty: 'Quant.',
+    btnRemoveTitle: 'Remover',
+    statStockUsed: 'Material Usado',
+    statTotalCuts: 'Cortes Totais',
+    statWaste: 'Desperdício Total',
+    statEfficiency: 'Eficiência',
+    vizTitle: 'Visualização de Corte',
+    emptyState: 'Adicione cortes e prima calcular para ver o plano de corte.',
+    noValidCuts: 'Não foi possível gerar cortes válidos. Verifique as medidas.',
+    noValidPanels: 'Não foi possível gerar painéis válidos. Verifique se as peças cabem na placa.',
+    stockLabel: 'Material',
+    panelLabel: 'Painel',
+    wasteLabel: 'Desperdício:',
+    effLabel: 'Efic:',
+  },
+};