@jjlmoya/utils-diy 1.3.0 → 1.5.0

package/src/tool/cutOptimizer/i18n/de.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 = 'schnittoptimierung';
+const title = 'Schnittoptimierung für Leisten und Platten';
+const description =
+  'Kostenloser Rechner zur Schnittoptimierung für Holz, Metall oder Rohre. Minimieren Sie den Verschnitt mit dem 1D- und 2D-Bin-Packing-Algorithmus. Ideal für Tischlerei und Metallbau.';
+
+const faqData = [
+  {
+    question: 'Was ist ein 1D-Schnittoptimierer?',
+    answer:
+      'Es ist ein Werkzeug, das mathematische Algorithmen (wie das Bin-Packing-Problem) verwendet, um zu bestimmen, wie kleinere Teile aus einem standardmäßigen Langstück (Leiste, Profil, Rohr) mit möglichst wenig Verschnitt geschnitten werden können.',
+  },
+  {
+    question: 'Warum muss die Schnittbreite (Kerf) berücksichtigt werden?',
+    answer:
+      'Jedes Mal, wenn die Säge durch das Material schneidet, gehen einige Millimeter verloren (normalerweise zwischen 2 mm und 4 mm, je nach Sägeblatt). Wenn dieser Platz nicht eingerechnet wird, werden die letzten Teile auf Ihrer Liste kürzer als geplant.',
+  },
+  {
+    question: 'Kann ich Teile verschiedener Längen mischen?',
+    answer:
+      'Ja, unser Rechner akzeptiert jede Kombination von Längen und Mengen. Der Algorithmus bewertet alle möglichen Kombinationen und priorisiert die maximale Ausnutzung des Lagermaterials.',
+  },
+  {
+    question: 'Wie speichere ich meinen Schnittplan?',
+    answer:
+      'Nach der Optimierung können Sie die Seite ausdrucken oder einen Screenshot des visuellen Schemas machen. Dies dient als physische Anleitung in der Werkstatt, um die Reihenfolge der Schnitte nicht zu verwechseln.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Basismaterial definieren (Stock)',
+    text: 'Geben Sie die Gesamtlänge der verfügbaren Leiste oder des Profils an (z. B. 2400 mm oder 6000 mm).',
+  },
+  {
+    name: 'Sägeblattdicke konfigurieren (Kerf)',
+    text: 'Stellen Sie die Millimeter ein, die die Säge bei jedem Schnitt entfernt, damit die Berechnung millimetergenau ist.',
+  },
+  {
+    name: 'Gewünschte Teile auflisten',
+    text: 'Geben Sie die Länge und Anzahl jedes Teils ein, das Sie für Ihr Projekt benötigen.',
+  },
+  {
+    name: 'Optimierung ausführen',
+    text: 'Erhalten Sie das effizienteste Schnittschema und den exakten Prozentsatz des erzeugten Verschnitts.',
+  },
+];
+
+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: 'de',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Häufig gestellte Fragen',
+  faq: faqData,
+  bibliographyTitle: 'Technische Referenzen',
+  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: 'Der definitive Leitfaden zur Schnittoptimierung',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Die Schnittoptimierung, technisch bekannt als das <strong>Zuschnittproblem (Cutting Stock Problem)</strong>, ist eine der faszinierendsten logistischen Herausforderungen in der Industrietechnik. Bei einem Projekt mit 20 Teilen und 5 Lagerstäben gibt es Millionen möglicher Kombinationen. Ein Computer-Algorithmus kann die optimale Lösung in Millisekunden finden und den üblichen Verschnitt von 15 % auf weniger als 5 % reduzieren.',
+    },
+    {
+      type: 'title',
+      text: 'Linearer 1D-Schnitt und 2D-Plattenschnitt',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Linearschnitt für Leisten und Profile',
+      html: '<p>Beim <strong>linearen Schnitt (1D)</strong> erfolgt die Optimierung in nur einer Dimension: der Länge. Die Breite des Materials wird als konstant angenommen. Ideal für Bauholz (Leisten, Balken), Metall- und Aluminiumprofile, PVC- oder Kupferrohre und Gewindestangen.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Plattenschnitt für Platten und Bleche',
+      html: '<p>Beim <strong>Plattenschnitt (2D)</strong> werden zwei Dimensionen verwaltet: Breite und Länge. Das Tool verwendet Guillotine-Algorithmen, bei denen jeder Schnitt von Kante zu Kante verläuft. Ideal für Plattenwerkstoffe (MDF, Spanplatten), Sperrholz, Glas, Acrylglas und Metallbleche.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Der kritische Faktor: Die Schnittbreite (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der <strong>Kerf</strong> ist das Material, das bei jedem Schnitt entfernt wird. Ein Standard-Tischkreissägeblatt verbraucht zwischen 3,0 mm und 3,2 mm pro Schnitt. Eine Handkreissäge verbraucht 1,5 bis 2,5 mm. Ein Laserschnitt in Acrylglas verbraucht kaum 0,1 bis 0,3 mm. Das Ignorieren der Schnittbreite in einem Projekt mit 10 Schnitten an 2400-mm-Leisten kann dazu führen, dass Sie zwischen 30 mm und 32 mm nutzbares Material verlieren.',
+    },
+    {
+      type: 'title',
+      text: 'Der Best-Fit-Decreasing-Algorithmus',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Wie der Optimierer intern funktioniert',
+      html: '<p>Der Kern des Optimierers nutzt die Strategie <strong>Best Fit Decreasing (BFD)</strong>: Zuerst werden alle Teile von der größten zur kleinsten Länge sortiert (große Teile sind schwieriger einzupassen). Dann wird für jedes Teil der vorhandene Rest gesucht, in den es mit dem geringsten verbleibenden Rest passt. Nur wenn es in keinen Rest passt, wird ein neuer Rohstab angebrochen. Dieser Prozess reduziert den Verschnitt um eine Größenordnung im Vergleich zur zufälligen Auswahl.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Linear (Stäbe)',
+    modePanelLabel: 'Platten',
+    configTitle: 'Materialkonfiguration',
+    labelStockLength: 'Materiallänge (mm)',
+    labelStockWidth: 'Materialbreite (mm)',
+    labelKerf: 'Schnittbreite / Kerf (mm)',
+    cutsTitle: 'Schnittliste',
+    placeholderLength: 'Länge',
+    placeholderWidth: 'Breite',
+    placeholderQty: 'Anz.',
+    btnRemoveTitle: 'Löschen',
+    statStockUsed: 'Material benutzt',
+    statTotalCuts: 'Gesamtschnitte',
+    statWaste: 'Gesamtverschnitt',
+    statEfficiency: 'Effizienz',
+    vizTitle: 'Schnittvisualisierung',
+    emptyState: 'Fügen Sie Schnitte hinzu und klicken Sie auf Berechnen, um den Schnittplan zu sehen.',
+    noValidCuts: 'Es konnten keine gültigen Schnitte generiert werden. Überprüfen Sie die Maße.',
+    noValidPanels: 'Es konnten keine gültigen Platten generiert werden. Prüfen Sie, ob die Teile auf die Platte passen.',
+    stockLabel: 'Material',
+    panelLabel: 'Platte',
+    wasteLabel: 'Verschnitt:',
+    effLabel: 'Eff:',
+  },
+};

package/src/tool/cutOptimizer/i18n/id.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 = 'pengoptimal-potongan';
+const title = 'Pengoptimal Potongan Kayu dan Papan';
+const description =
+  'Kalkulator gratis untuk mengoptimalkan potongan kayu, logam, atau pipa. Minimalkan sisa dengan algoritma Bin Packing 1D dan 2D. Ideal untuk bengkel kayu, metalurgi, dan renovasi.';
+
+const faqData = [
+  {
+    question: 'Apa itu pengoptimal potongan 1D?',
+    answer:
+      'Ini adalah alat yang menggunakan algoritma matematika (seperti Bin Packing Problem) untuk menentukan cara memotong bagian yang lebih kecil dari bagian panjang standar (balok, profil, pipa) dengan sisa sesedikit mungkin.',
+  },
+  {
+    question: 'Mengapa harus memasukkan ketebalan potongan (Kerf)?',
+    answer:
+      'Setiap kali gergaji memotong material, beberapa milimeter akan terbuang (biasanya antara 2mm hingga 4mm tergantung pisaunya). Jika Anda tidak menghitung ruang ini, bagian terakhir dari daftar Anda akan menjadi lebih pendek dari yang direncanakan.',
+  },
+  {
+    question: 'Dapatkah saya mencampur bagian dengan panjang yang berbeda?',
+    answer:
+      'Ya, kalkulator kami menerima kombinasi panjang dan jumlah berapa pun. Algoritma akan mengevaluasi semua kombinasi yang mungkin dan memprioritaskan pemanfaatan maksimal dari material stok.',
+  },
+  {
+    question: 'Bagaimana cara menyimpan rencana pemotongan saya?',
+    answer:
+      'Setelah dioptimalkan, Anda dapat mencetak halaman tersebut atau mengambil tangkapan layar dari skema visual. Ini akan berfungsi sebagai panduan fisik di bengkel agar urutan potongan tidak tertukar.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Tentukan material dasar (Stock)',
+    text: 'Masukkan total panjang balok atau profil yang tersedia (misalnya 2400mm atau 6000mm).',
+  },
+  {
+    name: 'Atur ketebalan pisau (Kerf)',
+    text: 'Sesuaikan milimeter yang dihilangkan gergaji pada setiap langkah agar perhitungannya akurat secara milimetrik.',
+  },
+  {
+    name: 'Daftar bagian yang diinginkan',
+    text: 'Tulis panjang dan jumlah setiap bagian yang Anda butuhkan untuk proyek Anda.',
+  },
+  {
+    name: 'Jalankan optimasi',
+    text: 'Dapatkan skema pemotongan paling efisien dan persentase tepat dari sisa yang dihasilkan.',
+  },
+];
+
+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: 'id',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Pertanyaan Umum',
+  faq: faqData,
+  bibliographyTitle: 'Referensi Teknis',
+  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: 'Panduan Definitif Optimasi Pemotongan',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Optimasi pemotongan, yang secara teknis dikenal sebagai <strong>Masalah Pemotongan Stok (Cutting Stock Problem)</strong>, adalah salah satu tantangan logistik paling menarik dalam teknik industri. Untuk proyek dengan 20 bagian dan 5 batang stok, ada jutaan kemungkinan kombinasi. Algoritma komputer dapat menemukan solusi optimal dalam hitungan milidetik, mengurangi sisa yang biasanya 15% menjadi kurang dari 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Pemotongan Linear 1D dan Pemotongan Panel 2D',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Pemotongan Linear untuk Batang dan Profil',
+      html: '<p>Dalam <strong>pemotongan linear (1D)</strong>, optimasi terjadi hanya dalam satu dimensi: panjang. Lebar material dianggap konstan. Sangat ideal untuk kayu dimensional (balok, gelagar), profil logam dan aluminium, pipa PVC atau tembaga, dan batang berulir.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Pemotongan Panel untuk Papan dan Lembaran',
+      html: '<p>Dalam <strong>pemotongan panel (2D)</strong>, dua dimensi dikelola: lebar dan panjang. Alat ini menggunakan algoritma tipe guillotine, di mana setiap potongan dilakukan dari tepi ke tepi. Ideal untuk papan turunan (MDF, partikel), kayu lapis, kaca, metakrilat, dan lembaran logam.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Faktor Kritis: Ketebalan Potongan (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: '<strong>Kerf</strong> adalah material yang hilang pada setiap potongan. Pisau gergaji meja standar menghabiskan antara 3,0mm hingga 3,2mm per potongan. Gergaji sirkuler genggam menghabiskan 1,5 hingga 2,5mm. Potongan laser pada metakrilat hanya 0,1 hingga 0,3mm. Mengabaikan kerf dalam proyek dengan 10 potongan pada balok sepanjang 2400mm dapat membuat Anda kehilangan antara 30mm hingga 32mm material yang berguna.',
+    },
+    {
+      type: 'title',
+      text: 'Algoritma Best Fit Decreasing',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Cara Kerja Pengoptimal Secara Internal',
+      html: '<p>Inti dari pengoptimal menggunakan strategi <strong>Best Fit Decreasing (BFD)</strong>: pertama-tama mengurutkan semua bagian dari panjang terbesar ke terkecil (bagian besar lebih sulit untuk dicocokkan). Kemudian, untuk setiap bagian, ia mencari sisa yang ada di mana ia dapat masuk dengan meninggalkan sisa sesedikit mungkin. Hanya jika tidak muat di sisa mana pun, ia akan membuka batang baru. Proses ini mengurangi sisa secara signifikan dibandingkan dengan pemilihan acak.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Linear (Batang)',
+    modePanelLabel: 'Panel (Papan)',
+    configTitle: 'Konfigurasi Material',
+    labelStockLength: 'Panjang Material (mm)',
+    labelStockWidth: 'Lebar Material (mm)',
+    labelKerf: 'Ketebalan Pisau / Kerf (mm)',
+    cutsTitle: 'Daftar Potongan',
+    placeholderLength: 'Panjang',
+    placeholderWidth: 'Lebar',
+    placeholderQty: 'Jml.',
+    btnRemoveTitle: 'Hapus',
+    statStockUsed: 'Material Terpakai',
+    statTotalCuts: 'Total Potongan',
+    statWaste: 'Total Sisa',
+    statEfficiency: 'Efisiensi',
+    vizTitle: 'Visualisasi Potongan',
+    emptyState: 'Tambahkan potongan dan tekan hitung untuk melihat rencana potongan.',
+    noValidCuts: 'Tidak dapat menghasilkan potongan yang valid. Periksa ukurannya.',
+    noValidPanels: 'Tidak dapat menghasilkan panel yang valid. Pastikan bagian-bagian tersebut muat di papan.',
+    stockLabel: 'Material',
+    panelLabel: 'Panel',
+    wasteLabel: 'Sisa:',
+    effLabel: 'Efis:',
+  },
+};

package/src/tool/cutOptimizer/i18n/it.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 = 'ottimizzatore-taglio';
+const title = 'Ottimizzatore di Taglio per Listelli e Pannelli';
+const description =
+  'Calcolatrice gratuita per ottimizzare i tagli di legno, metallo o tubi. Minimizza lo scarto con algoritmi Bin Packing 1D e 2D. Ideale per falegnameria e carpenteria.';
+
+const faqData = [
+  {
+    question: 'Cos\'è un ottimizzatore di taglio 1D?',
+    answer:
+      'È uno strumento che utilizza algoritmi matematici (come il Bin Packing Problem) per determinare come tagliare pezzi più piccoli da un pezzo lungo standard (listello, profilo, tubo) con il minimo scarto possibile.',
+  },
+  {
+    question: 'Perché includere lo spessore del taglio (Kerf)?',
+    answer:
+      'Ogni volta che la sega taglia il materiale, vengono consumati alcuni millimetri (normalmente tra 2mm e 4mm a seconda del disco). Se non calcoli questo spazio, gli ultimi pezzi della tua lista risulteranno più corti del previsto.',
+  },
+  {
+    question: 'Posso mischiare pezzi di lunghezze diverse?',
+    answer:
+      'Sì, la nostra calcolatrice accetta qualsiasi combinazione di lunghezze e quantità. L\'algoritmo valuterà tutte le combinazioni possibili e darà priorità al massimo sfruttamento del materiale di stock.',
+  },
+  {
+    question: 'Come salvo il mio piano di taglio?',
+    answer:
+      'Una volta ottimizzato, puoi stampare la pagina o fare uno screenshot dello schema visivo. Questo ti servirà da guida fisica in officina per non confondere l\'ordine dei tagli.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Definire il materiale base (Stock)',
+    text: 'Inserisci la lunghezza totale del listello o profilo disponibile (es. 2400mm o 6000mm).',
+  },
+  {
+    name: 'Configurare lo spessore del disco (Kerf)',
+    text: 'Imposta i millimetri che la sega elimina ad ogni passaggio affinché il calcolo sia millimetrico.',
+  },
+  {
+    name: 'Elencare i pezzi desiderati',
+    text: 'Scrivi la lunghezza e la quantità di ogni pezzo di cui hai bisogno per il tuo progetto.',
+  },
+  {
+    name: 'Eseguire l\'ottimizzazione',
+    text: 'Ottieni lo schema di taglio più efficiente e la percentuale esatta di scarto generato.',
+  },
+];
+
+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: 'it',
+};
+
+export const content: ToolLocaleContent<CutOptimizerUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Domande Frequenti',
+  faq: faqData,
+  bibliographyTitle: 'Riferimenti Tecnici',
+  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: 'Guida Definitiva all\'Ottimizzazione del Taglio',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'L\'ottimizzazione del taglio, nota tecnicamente come il <strong>Problema del Taglio dello Stock (Cutting Stock Problem)</strong>, è una delle sfide logistiche più affascinanti nell\'ingegneria industriale. Per un progetto con 20 pezzi e 5 barre di stock, esistono milioni di combinazioni possibili. Un algoritmo computazionale può trovare la soluzione ottimale in millisecondi, riducendo lo scarto abituale del 15% a meno del 5%.',
+    },
+    {
+      type: 'title',
+      text: 'Taglio Lineare 1D e Taglio di Pannelli 2D',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:arrow-expand-horizontal',
+      title: 'Taglio Lineare per Listelli e Profili',
+      html: '<p>Nel <strong>taglio lineare (1D)</strong>, l\'ottimizzazione avviene in una sola dimensione: la lunghezza. La larghezza del materiale è assunta costante. È ideale per legno dimensionale (listelli, travi), profilati metallici e di alluminio, tubi in PVC o rame, e barre filettate.</p>',
+    },
+    {
+      type: 'card',
+      icon: 'mdi:view-grid',
+      title: 'Taglio di Pannelli per Tavole e Lamiere',
+      html: '<p>Nel <strong>taglio di pannelli (2D)</strong>, si gestiscono due dimensioni: larghezza e lunghezza. Lo strumento utilizza algoritmi di tipo ghigliottina, dove ogni taglio va da bordo a bordo. Ideale per pannelli derivati (MDF, truciolato), compensato, vetro, metacrilato e lamiere metalliche.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Il Fattore Critico: Lo Spessore del Taglio (Kerf)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Il <strong>Kerf</strong> è il materiale che viene eliminato ad ogni taglio. Un disco di sega circolare standard da banco consuma tra 3,0mm e 3,2mm per taglio. Una sega circolare a mano ne consuma da 1,5 a 2,5mm. Un taglio laser sul metacrilato appena 0,1-0,3mm. Ignorare il kerf in un progetto con 10 tagli su listelli da 2400mm può farti perdere tra 30mm e 32mm di materiale utile.',
+    },
+    {
+      type: 'title',
+      text: 'L\'Algoritmo Best Fit Decreasing',
+      level: 3,
+    },
+    {
+      type: 'card',
+      icon: 'mdi:chip',
+      title: 'Come Funziona l\'Ottimizzatore Internamente',
+      html: '<p>Il cuore dell\'ottimizzatore utilizza la strategia <strong>Best Fit Decreasing (BFD)</strong>: prima ordina tutti i pezzi dalla lunghezza maggiore alla minore (i pezzi grandi sono più difficili da incastrare). Poi, per ogni pezzo, cerca il resto esistente dove possa entrare lasciando il minor avanzo possibile. Solo se non entra in nessun resto, apre una nuova barra vergine. Questo processo riduce lo scarto di un ordine di grandezza rispetto alla selezione casuale.</p>',
+    },
+  ],
+  ui: {
+    modeLinearLabel: 'Lineare (Barre)',
+    modePanelLabel: 'Pannello (Tavole)',
+    configTitle: 'Configurazione Materiale',
+    labelStockLength: 'Lunghezza Materiale (mm)',
+    labelStockWidth: 'Larghezza Materiale (mm)',
+    labelKerf: 'Spessore Lama / Kerf (mm)',
+    cutsTitle: 'Lista Tagli',
+    placeholderLength: 'Lunghezza',
+    placeholderWidth: 'Larghezza',
+    placeholderQty: 'Qtà',
+    btnRemoveTitle: 'Elimina',
+    statStockUsed: 'Materiale Usato',
+    statTotalCuts: 'Tagli Totali',
+    statWaste: 'Scarto Totale',
+    statEfficiency: 'Efficienza',
+    vizTitle: 'Visualizzazione Taglio',
+    emptyState: 'Aggiungi i tagli e premi calcola per vedere il piano di taglio.',
+    noValidCuts: 'Impossibile generare tagli validi. Verifica le misure.',
+    noValidPanels: 'Impossibile generare pannelli validi. Verifica che i pezzi entrino nella tavola.',
+    stockLabel: 'Materiale',
+    panelLabel: 'Pannello',
+    wasteLabel: 'Scarto:',
+    effLabel: 'Effic:',
+  },
+};