@jjlmoya/utils-games-development 1.51.0 → 1.53.0

package/src/tool/localizationSanitizer/entry.ts

@@ -0,0 +1,28 @@
+import type { GamesToolEntry, ToolLocaleContent } from '../../types';
+import type { LocalizationSanitizerUI } from './ui';
+
+export type { LocalizationSanitizerUI };
+
+export type LocalizationSanitizerLocaleContent = ToolLocaleContent<LocalizationSanitizerUI>;
+
+export const localizationSanitizer: GamesToolEntry<LocalizationSanitizerUI> = {
+  id: 'localization-sanitizer',
+  icons: { bg: 'mdi:gamepad-variant', fg: 'mdi:file-document-check-outline' },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/localizationSanitizer/i18n/de.ts

@@ -0,0 +1,176 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { LocalizationSanitizerUI } from '../ui';
+
+export const content: ToolLocaleContent<LocalizationSanitizerUI> = {
+  slug: 'bereinigung-lokalisierungsdateien-godot-unity',
+  title: 'Godot und Unity Lokalisierungs CSV Bereinigung',
+  description: 'Pruefen Sie CSV oder JSON Uebersetzungsdateien auf leere Zellen, doppelte Schluessel und defekte Zeilen und exportieren Sie eine bereinigte Kopie.',
+  ui: {
+    csvTab: 'CSV Datei',
+    jsonTab: 'JSON Datei',
+    dropTitle: 'Uebersetzungsdatei hier ablegen',
+    dropSubtitle: 'Struktur im Browser pruefen und Quelldatei lokal behalten.',
+    browseButton: 'Dateien durchsuchen',
+    sampleButton: 'Beispiel laden',
+    clearButton: 'Leeren',
+    inputLabel: 'Uebersetzungsdateieingabe',
+    formatLabel: 'Format',
+    healthLabel: 'Dateizustand',
+    readyStatus: 'Bereit zum Import',
+    reviewStatus: 'Ueberpruefung erforderlich',
+    emptyCellsLabel: 'Leere Zellen',
+    duplicateKeysLabel: 'Doppelte Schluessel',
+    malformedRowsLabel: 'Defekte Zeilen',
+    cleanRowsLabel: 'Saubere Zeilen',
+    issueListTitle: 'Befunde',
+    noIssues: 'Keine Probleme in diesem Durchgang gefunden.',
+    previewTitle: 'Uebersetzungsvorschau',
+    previewSubtitle: 'Die ersten Zeilen zeigen die normalisierte Struktur fuer den Export.',
+    exportTitle: 'Saubere Datei exportieren',
+    exportSubtitle: 'Duplikate werden entfernt fehlende Spalten aufgefuellt und CSV Werte maskiert.',
+    downloadButton: 'Saubere Datei herunterladen',
+    copyButton: 'Ausgabe kopieren',
+    copiedMessage: 'Bereinigte Ausgabe in Zwischenablage kopiert.',
+    emptyIssue: 'Leere Uebersetzungszelle',
+    duplicateIssue: 'Doppelter Schluessel entfernt',
+    malformedIssue: 'Spalten oder Anfuehrungszeichenfehler',
+    parseIssue: 'Die Datei konnte nicht gelesen werden.',
+    rowLabel: 'Zeile',
+    columnLabel: 'Spalte',
+    keyLabel: 'Schluessel',
+    sampleFileName: 'lokalisierungs-beispiel.csv',
+    privacyNote: 'Lokale Browserverarbeitung',
+    waitingTitle: 'Warten auf eine Datei',
+    waitingSubtitle: 'Legen Sie eine CSV oder JSON Datei ab um die Pruefung zu starten.',
+    fileTypeNote: 'UTF8 CSV oder strukturiertes JSON',
+  },
+  seo: [
+    { type: 'title', level: 2, text: 'Warum Lokalisierungsdateien beim Engine Import fehlschlagen' },
+    {
+      type: 'paragraph',
+      html: 'Uebersetzungstabellen sind einfach zu bearbeiten und leicht zu beschaedigen. Ein Komma in einem Text oder fehlende Anfuehrungszeichen koennen alle Werte in die falsche Sprachspalte verschieben. Ein doppelter Schluessel führt ebenfalls zu Problemen beim Import.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Der CSV Import von Godot erwartet eine Kopfzeile, eine erste Bezeichnerspalte und konsistente Uebersetzungsspalten. Das Unity Localization Paket nutzt ebenfalls CSV. Dieses Tool prueft die Struktur vor dem Import.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { value: 'CSV', label: 'Kommapruefung' },
+        { value: 'JSON', label: 'Array und Map Eingabe' },
+        { value: '0 Uploads', label: 'Nur im Browser' },
+        { value: '1 Klick', label: 'Sauberer Export' },
+      ],
+    },
+    { type: 'title', level: 2, text: 'Was das Tool ueberprueft' },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Vor dem Import erkannt',
+          description: 'Schwer zu findende Probleme in grossen Tabellen',
+          points: ['Leere Zellen', 'Doppelte Bezeichner', 'Zeilen mit fehlenden Spalten', 'Ungültige Anfuehrungszeichen'],
+        },
+        {
+          title: 'Fuer Export normalisiert',
+          description: 'Sichere automatische Reparaturen',
+          points: ['Fehlende Zellen werden aufgefuellt', 'Zusaetzliche Felder zusammengefuehrt', 'Erste Vorkommen behalten', 'Originaldatei bleibt unberuehrt'],
+        },
+      ],
+    },
+    { type: 'title', level: 2, text: 'Ueberpruefung der bereinigten Datei' },
+    {
+      type: 'paragraph',
+      html: 'Eine strukturelle Bereinigung ersetzt keine sprachliche Ueberpruefung. Nutzen Sie die Befundliste zur Nachbearbeitung.',
+    },
+    {
+      type: 'table',
+      headers: ['Befund', 'Bedeutung', 'Naechster Schritt'],
+      rows: [
+        ['Leere Zelle', 'Eine Sprachspalte ist leer', 'Uebersetzen oder als beabsichtigt bestaetigen'],
+        ['Doppelter Schluessel', 'Schluessel mehrfach vorhanden', 'Zeilen vergleichen und erste Vorkommen verwenden'],
+        ['Defekte Zeile', 'Spaltenanzahl weicht ab', 'Normalisiertes Ergebnis pruefen'],
+        ['Parse Fehler', 'JSON ungueltig', 'Syntax vor Import korrigieren'],
+      ],
+    },
+    { type: 'title', level: 2, text: 'CSV Konventionen fuer Spiele' },
+    {
+      type: 'paragraph',
+      html: 'Standard CSV Regeln: Felder sind durch Kommas getrennt, Sonderzeichen werden in Anfuehrungszeichen eingeschlossen.',
+    },
+    {
+      type: 'tip',
+      title: 'Originaldatei aufbewahren',
+      html: 'Vergleichen Sie den Export stets mit der Originaldatei vor der Einbindung ins Spiel.',
+    },
+    {
+      type: 'glossary',
+      items: [
+        { term: 'Uebersetzungsschluessel', definition: 'Stabil bezeichneter Bezeichner fuer einen Spieltext.' },
+        { term: 'CSV Feld', definition: 'Ein Einzelwert zwischen Trennzeichen.' },
+        { term: 'Escaping', definition: 'Einschluss in Anfuehrungszeichen fuer Sonderzeichen.' },
+        { term: 'Locale', definition: 'Sprach und Regionalkennung wie de oder en.' },
+      ],
+    },
+  ],
+  faq: [
+    {
+      question: 'Werden Dateien hochgeladen?',
+      answer: 'Nein, die Verarbeitung findet vollstaendig lokal im Browser statt.',
+    },
+    {
+      question: 'Was passiert bei zusaetzlichen Kommas?',
+      answer: 'Zusaetzliche Felder werden in die letzte Spalte zusammengefuehrt.',
+    },
+    {
+      question: 'Wie werden Duplikate bereinigt?',
+      answer: 'Das erste Vorkommen wird behalten, weitere werden entfernt.',
+    },
+    {
+      question: 'Prueft das Tool die Uebersetzungsqualitaet?',
+      answer: 'Nein, es prueft nur die Dateistruktur und Vollstaendigkeit.',
+    },
+  ],
+  howTo: [
+    { name: 'Dateiformat waehlen', text: 'Waehlen Sie CSV oder JSON aus.' },
+    { name: 'Befunde pruefen', text: 'Datei ablegen und Fehlerliste durchgehen.' },
+    { name: 'Exportieren und testen', text: 'Saubere Datei herunterladen und in der Engine testen.' },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Godot und Unity Lokalisierungs CSV Bereinigung',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [{
+        '@type': 'Question',
+        name: 'Werden Dateien hochgeladen?',
+        acceptedAnswer: { '@type': 'Answer', text: 'Nein, die Verarbeitung findet vollstaendig lokal im Browser statt.' },
+      }],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'Lokalisierungsdatei bereinigen',
+      step: [
+        { '@type': 'HowToStep', name: 'Dateiformat waehlen', text: 'Waehlen Sie CSV oder JSON aus.' },
+        { '@type': 'HowToStep', name: 'Befunde pruefen', text: 'Datei ablegen und Fehlerliste durchgehen.' },
+        { '@type': 'HowToStep', name: 'Exportieren und testen', text: 'Saubere Datei herunterladen und in der Engine testen.' },
+      ],
+    },
+  ],
+  bibliography: [
+    { name: 'Godot ResourceImporterCSVTranslation Dokus', url: 'https://docs.godotengine.org/en/stable/classes/class_resourceimportercsvtranslation.html' },
+    { name: 'Unity Localization CSV Import Doku', url: 'https://docs.unity3d.com/Packages/com.unity.localization@1.5/manual/CSV.html' },
+    { name: 'RFC 4180 CSV Spezifikation', url: 'https://datatracker.ietf.org/doc/html/rfc4180' },
+  ],
+};

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

@@ -0,0 +1,176 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { LocalizationSanitizerUI } from '../ui';
+
+export const content: ToolLocaleContent<LocalizationSanitizerUI> = {
+  slug: 'localization-sanitizer',
+  title: 'Godot and Unity Localization CSV Sanitizer',
+  description: 'Inspect translation CSV or JSON files for empty cells, duplicate keys, and broken rows, then export a clean local copy ready for engine import.',
+  ui: {
+    csvTab: 'CSV file',
+    jsonTab: 'JSON file',
+    dropTitle: 'Drop a translation file here',
+    dropSubtitle: 'Inspect the structure in your browser and keep the source file on your device.',
+    browseButton: 'Browse files',
+    sampleButton: 'Load sample',
+    clearButton: 'Clear',
+    inputLabel: 'Translation file input',
+    formatLabel: 'Format',
+    healthLabel: 'File health',
+    readyStatus: 'Ready to import',
+    reviewStatus: 'Needs review',
+    emptyCellsLabel: 'Empty cells',
+    duplicateKeysLabel: 'Duplicate keys',
+    malformedRowsLabel: 'Broken rows',
+    cleanRowsLabel: 'Clean rows',
+    issueListTitle: 'Findings',
+    noIssues: 'No issues found in this pass.',
+    previewTitle: 'Translation preview',
+    previewSubtitle: 'The first rows show the normalized structure that will be exported.',
+    exportTitle: 'Export clean file',
+    exportSubtitle: 'Duplicates are removed missing columns are padded and CSV values are escaped again.',
+    downloadButton: 'Download clean file',
+    copyButton: 'Copy output',
+    copiedMessage: 'Clean output copied to clipboard.',
+    emptyIssue: 'Empty translation cell',
+    duplicateIssue: 'Duplicate key removed',
+    malformedIssue: 'Column or quote mismatch',
+    parseIssue: 'The file could not be parsed.',
+    rowLabel: 'Row',
+    columnLabel: 'Column',
+    keyLabel: 'Key',
+    sampleFileName: 'localization-sample.csv',
+    privacyNote: 'Local browser processing',
+    waitingTitle: 'Waiting for a file',
+    waitingSubtitle: 'Drop CSV or JSON to start the inspection.',
+    fileTypeNote: 'UTF8 CSV or structured JSON',
+  },
+  seo: [
+    { type: 'title', level: 2, text: 'Why localization files break during engine import' },
+    {
+      type: 'paragraph',
+      html: 'Translation tables are simple to edit and surprisingly easy to damage. A comma inside a phrase, a missing pair of quotes, or one row with a different number of fields can shift every value to the wrong language column. A repeated key can be just as disruptive because the engine no longer has one unambiguous source string to import.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Godot CSV translation importer expects a header row, a first column of identifiers, and consistent translation columns. Unity Localization package also uses CSV to exchange string table data with translators. This sanitizer gives you a small inspection pass before you hand a file back to an engine: it checks the shape, highlights unfinished cells, keeps the first copy of a repeated key, and writes a normalized export.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { value: 'CSV', label: 'Quoted commas checked' },
+        { value: 'JSON', label: 'Array and map input' },
+        { value: '0 uploads', label: 'Browser-only workflow' },
+        { value: '1 click', label: 'Clean export' },
+      ],
+    },
+    { type: 'title', level: 2, text: 'What the sanitizer checks' },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Detected before import',
+          description: 'Problems that are hard to spot in a long translation table',
+          points: ['Empty language cells that still need a translation', 'Repeated identifiers that would create ambiguous rows', 'CSV records with missing or extra columns', 'Quotes that do not follow the normal CSV field rules'],
+        },
+        {
+          title: 'Normalized for export',
+          description: 'Small, predictable repairs that are safe to review',
+          points: ['Missing CSV cells are padded so every row matches the header', 'Extra CSV fields are joined into the final cell and escaped', 'The first row for a duplicate key is retained', 'The original file remains untouched for comparison or rollback'],
+        },
+      ],
+    },
+    { type: 'title', level: 2, text: 'How to review a cleaned localization file' },
+    {
+      type: 'paragraph',
+      html: 'A clean parse is a structural result, not a language review. Use the findings list to locate missing work, then read the exported file in the engine that will consume it. Check that the identifier column is the column your project expects, that locale headers match the project settings, and that intentional empty values are understood by the runtime. The sanitizer does not judge grammar, placeholders, plural rules, or context-sensitive terminology.',
+    },
+    {
+      type: 'table',
+      headers: ['Finding', 'What it means', 'Next action'],
+      rows: [
+        ['Empty cell', 'A non-key column contains no text', 'Translate it or confirm that an empty value is intentional'],
+        ['Duplicate key', 'More than one row uses the same identifier', 'Compare the rows before keeping the exported first occurrence'],
+        ['Broken row', 'The row shape or quote syntax differs from the header', 'Review the normalized final cell and compare with the source'],
+        ['Parse error', 'The JSON structure cannot be read', 'Fix the syntax in a JSON editor before importing'],
+      ],
+    },
+    { type: 'title', level: 2, text: 'CSV conventions that matter for game localization' },
+    {
+      type: 'paragraph',
+      html: 'The common CSV rules are deliberately modest: fields are separated by commas, records have a consistent field count, and a field containing a comma, a line break, or a quote can be enclosed in double quotes. A quote inside a quoted field is represented by two quotes. These details matter for translated phrases because punctuation is part of natural language, not a reliable delimiter.',
+    },
+    {
+      type: 'tip',
+      title: 'Keep the original beside the clean export',
+      html: 'The export is a repair aid, not a replacement for source control. Keep the translator original file, inspect any broken row whose comma was joined into the final column, and run the cleaned file through the target engine before committing it to your project.',
+    },
+    {
+      type: 'glossary',
+      items: [
+        { term: 'Translation key', definition: 'A stable identifier used by game code to request a localized string.' },
+        { term: 'CSV field', definition: 'One value between separators in a comma-separated record.' },
+        { term: 'Escaping', definition: 'The quoting convention that lets punctuation remain part of a value instead of becoming a separator.' },
+        { term: 'Locale', definition: 'A language and regional convention such as en, es, or ja used to select a translation column.' },
+      ],
+    },
+  ],
+  faq: [
+    {
+      question: 'Does this tool upload my translation file?',
+      answer: 'No network upload is used by the sanitizer interface. The selected text is read by the browser, analyzed locally, and turned into a download in the same browser session. As with any web tool, review your site own analytics and deployment policy if you embed or customize this component.',
+    },
+    {
+      question: 'What happens when a CSV row has an extra comma?',
+      answer: 'The row is flagged as malformed and the extra fields are joined into the final column before export. This is useful for the common case where a last translation contains an unescaped comma, but you should review the flagged row because a comma in a middle column cannot be inferred with certainty.',
+    },
+    {
+      question: 'How are duplicate translation keys cleaned?',
+      answer: 'The first occurrence is kept in the clean output and later occurrences are omitted from the exported file. The findings list shows each removed duplicate so you can compare the source rows and decide whether the first row is the intended one.',
+    },
+    {
+      question: 'Can it validate the quality of a translation?',
+      answer: 'It checks file structure and missing values, not grammar or meaning. It does not validate placeholders, plurals, gender, context, or whether the wording is correct for your game. Those checks still need a translator, reviewer, or engine-specific validation step.',
+    },
+  ],
+  howTo: [
+    { name: 'Choose the file format', text: 'Select CSV or JSON, or let the tool detect the format from the file name and contents.' },
+    { name: 'Inspect the findings', text: 'Drop the translation file, review the health score, and use the findings list to locate empty cells, duplicate keys, and malformed rows.' },
+    { name: 'Export and test', text: 'Download or copy the normalized output, compare any repaired rows with the original, and import it into your Godot or Unity project.' },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Godot and Unity Localization CSV Sanitizer',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [{
+        '@type': 'Question',
+        name: 'What happens when a CSV row has an extra comma?',
+        acceptedAnswer: { '@type': 'Answer', text: 'The row is flagged as malformed and the extra fields are joined into the final column before export for review.' },
+      }],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'How to sanitize a game localization file',
+      step: [
+        { '@type': 'HowToStep', name: 'Choose the file format', text: 'Select CSV or JSON and load the translation file.' },
+        { '@type': 'HowToStep', name: 'Inspect the findings', text: 'Review empty cells, duplicate keys, and malformed rows.' },
+        { '@type': 'HowToStep', name: 'Export and test', text: 'Download the clean output and import it into the target engine.' },
+      ],
+    },
+  ],
+  bibliography: [
+    { name: 'Godot ResourceImporterCSVTranslation Documentation', url: 'https://docs.godotengine.org/en/stable/classes/class_resourceimportercsvtranslation.html' },
+    { name: 'Unity Localization CSV Import and Export Documentation', url: 'https://docs.unity3d.com/Packages/com.unity.localization@1.5/manual/CSV.html' },
+    { name: 'RFC 4180 Common Format and MIME Type for CSV Files', url: 'https://datatracker.ietf.org/doc/html/rfc4180' },
+  ],
+};

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

@@ -0,0 +1,176 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { LocalizationSanitizerUI } from '../ui';
+
+export const content: ToolLocaleContent<LocalizationSanitizerUI> = {
+  slug: 'depurador-csv-localizacion-godot-unity',
+  title: 'Depurador de Archivos CSV y JSON de Localizacion para Godot y Unity',
+  description: 'Inspeccione archivos CSV o JSON de traduccion en busca de celdas vacias, claves duplicadas y filas defectuosas, y exporte una copia limpia lista para el motor.',
+  ui: {
+    csvTab: 'Archivo CSV',
+    jsonTab: 'Archivo JSON',
+    dropTitle: 'Arrastre un archivo de traduccion aqui',
+    dropSubtitle: 'Inspeccione la estructura en su navegador conservando el archivo fuente en su equipo.',
+    browseButton: 'Buscar archivos',
+    sampleButton: 'Cargar ejemplo',
+    clearButton: 'Limpiar',
+    inputLabel: 'Entrada de archivo de traduccion',
+    formatLabel: 'Formato',
+    healthLabel: 'Estado del archivo',
+    readyStatus: 'Listo para importar',
+    reviewStatus: 'Requiere revision',
+    emptyCellsLabel: 'Celdas vacias',
+    duplicateKeysLabel: 'Claves duplicadas',
+    malformedRowsLabel: 'Filas defectuosas',
+    cleanRowsLabel: 'Filas limpias',
+    issueListTitle: 'Hallazgos',
+    noIssues: 'No se encontraron problemas en este analisis.',
+    previewTitle: 'Vista previa de traduccion',
+    previewSubtitle: 'Las primeras filas muestran la estructura normalizada que se exportara.',
+    exportTitle: 'Exportar archivo limpio',
+    exportSubtitle: 'Se eliminan duplicados, se rellenan columnas faltantes y se escapan valores CSV.',
+    downloadButton: 'Descargar archivo limpio',
+    copyButton: 'Copiar resultado',
+    copiedMessage: 'Resultado limpio copiado al portapapeles.',
+    emptyIssue: 'Celda de traduccion vacia',
+    duplicateIssue: 'Clave duplicada eliminada',
+    malformedIssue: 'Disparidad de columnas o comillas',
+    parseIssue: 'No se pudo analizar el archivo.',
+    rowLabel: 'Fila',
+    columnLabel: 'Columna',
+    keyLabel: 'Clave',
+    sampleFileName: 'ejemplo-localizacion.csv',
+    privacyNote: 'Procesamiento local en el navegador',
+    waitingTitle: 'Esperando un archivo',
+    waitingSubtitle: 'Arrastre un archivo CSV o JSON para comenzar la inspeccion.',
+    fileTypeNote: 'CSV UTF-8 o JSON estructurado',
+  },
+  seo: [
+    { type: 'title', level: 2, text: 'Por que los archivos de localizacion fallan al importar en el motor' },
+    {
+      type: 'paragraph',
+      html: 'Las tablas de traduccion son sencillas de editar pero faciles de dañar. Una coma dentro de una frase o comillas faltantes pueden desplazar los valores a la columna de idioma incorrecta. Una clave duplicada genera ambiguedad al importar.',
+    },
+    {
+      type: 'paragraph',
+      html: 'El importador CSV de Godot requiere una fila de cabecera, una primera columna de identificadores y columnas de idioma consistentes. Unity Localization tambien utiliza CSV. Esta herramienta valida y normaliza la estructura antes de la importacion.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { value: 'CSV', label: 'Verificacion de comas' },
+        { value: 'JSON', label: 'Entrada de matrices y mapas' },
+        { value: '0 subidas', label: 'Procesamiento local' },
+        { value: '1 clic', label: 'Exportacion limpia' },
+      ],
+    },
+    { type: 'title', level: 2, text: 'Que verifica el depurador' },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Detectado antes de importar',
+          description: 'Problemas dificiles de detectar a simple vista',
+          points: ['Celdas de idioma vacias', 'Claves duplicadas', 'Registros con columnas sobrantes o faltantes', 'Sintaxis de comillas invalida'],
+        },
+        {
+          title: 'Normalizado para exportar',
+          description: 'Correcciones seguras y predecibles',
+          points: ['Columnas faltantes rellenadas', 'Campos extra unidos en la ultima columna', 'Se conserva la primera aparicion de clave', 'El archivo original no se modifica'],
+        },
+      ],
+    },
+    { type: 'title', level: 2, text: 'Como revisar el archivo depurado' },
+    {
+      type: 'paragraph',
+      html: 'La limpieza estructural no reemplaza la revision linguistica. Utilice la lista de hallazgos para completar traducciones pendientes.',
+    },
+    {
+      type: 'table',
+      headers: ['Hallazgo', 'Significado', 'Accion recomendada'],
+      rows: [
+        ['Celda vacia', 'Una columna de idioma no contiene texto', 'Traduzca o confirme si es intencional'],
+        ['Clave duplicada', 'Mas de una fila usa el mismo identificador', 'Compare las filas antes de usar la primera aparicion'],
+        ['Fila defectuosa', 'Estructura o comillas no coinciden con la cabecera', 'Revise la celda final normalizada'],
+        ['Error de analisis', 'El archivo JSON no se puede leer', 'Corrija la sintaxis antes de importar'],
+      ],
+    },
+    { type: 'title', level: 2, text: 'Convenciones CSV para videojuegos' },
+    {
+      type: 'paragraph',
+      html: 'Las reglas CSV basicas exigen campos separados por comas y delimitacion con comillas dobles cuando existen signos de puntuacion.',
+    },
+    {
+      type: 'tip',
+      title: 'Conserve el archivo original',
+      html: 'Mantenga el archivo original del traductor y pruebe la version limpia en el motor antes de confirmar cambios.',
+    },
+    {
+      type: 'glossary',
+      items: [
+        { term: 'Clave de traduccion', definition: 'Identificador unico utilizado por el codigo del juego.' },
+        { term: 'Campo CSV', definition: 'Valor individual entre delimitadores.' },
+        { term: 'Escapado', definition: 'Uso de comillas para mantener la puntuacion como texto.' },
+        { term: 'Locale', definition: 'Codigo de idioma y region como es, en o ja.' },
+      ],
+    },
+  ],
+  faq: [
+    {
+      question: '¿Se suben los archivos a un servidor?',
+      answer: 'No, todo el procesamiento se realiza localmente en el navegador.',
+    },
+    {
+      question: '¿Que ocurre si una fila CSV tiene comas adicionales?',
+      answer: 'La fila se marca como defectuosa y los campos extra se unen en la columna final.',
+    },
+    {
+      question: '¿Como se limpian las claves duplicadas?',
+      answer: 'Se conserva la primera aparicion y las siguientes se omiten del archivo limpio.',
+    },
+    {
+      question: '¿Valida la calidad de la traduccion?',
+      answer: 'No, solo verifica la estructura del archivo y campos faltantes.',
+    },
+  ],
+  howTo: [
+    { name: 'Seleccionar formato', text: 'Elija CSV o JSON.' },
+    { name: 'Inspeccionar hallazgos', text: 'Cargue el archivo y revise la lista de inconsistencias.' },
+    { name: 'Exportar y probar', text: 'Descargue la version limpia e importela en su motor.' },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Depurador de Archivos CSV y JSON de Localizacion para Godot y Unity',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [{
+        '@type': 'Question',
+        name: '¿Se suben los archivos a un servidor?',
+        acceptedAnswer: { '@type': 'Answer', text: 'No, todo el procesamiento se realiza localmente en el navegador.' },
+      }],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'Como depurar un archivo de localizacion',
+      step: [
+        { '@type': 'HowToStep', name: 'Seleccionar formato', text: 'Elija CSV o JSON.' },
+        { '@type': 'HowToStep', name: 'Inspeccionar hallazgos', text: 'Cargue el archivo y revise la lista de inconsistencias.' },
+        { '@type': 'HowToStep', name: 'Exportar y probar', text: 'Descargue la version limpia e importela en su motor.' },
+      ],
+    },
+  ],
+  bibliography: [
+    { name: 'Documentacion ResourceImporterCSVTranslation de Godot', url: 'https://docs.godotengine.org/en/stable/classes/class_resourceimportercsvtranslation.html' },
+    { name: 'Documentacion de importacion CSV en Unity Localization', url: 'https://docs.unity3d.com/Packages/com.unity.localization@1.5/manual/CSV.html' },
+    { name: 'Especificacion RFC 4180 CSV', url: 'https://datatracker.ietf.org/doc/html/rfc4180' },
+  ],
+};