From 6eebeed3789c37960c749166677daebc9db8d10d Mon Sep 17 00:00:00 2001 From: Lars Gebhardt-Kusche Date: Wed, 26 Nov 2025 00:28:47 +0100 Subject: [PATCH] language update --- public/assets/i18n/at.json | 227 +++++++++++++++++++++++++++++++----- public/assets/i18n/dk.json | 231 ++++++++++++++++++++++++++++++++----- public/assets/i18n/es.json | 231 ++++++++++++++++++++++++++++++++----- public/assets/i18n/fr.json | 231 ++++++++++++++++++++++++++++++++----- public/assets/i18n/it.json | 231 ++++++++++++++++++++++++++++++++----- public/assets/i18n/us.json | 229 +++++++++++++++++++++++++++++++----- 6 files changed, 1203 insertions(+), 177 deletions(-) diff --git a/public/assets/i18n/at.json b/public/assets/i18n/at.json index 3440491..a0d5487 100644 --- a/public/assets/i18n/at.json +++ b/public/assets/i18n/at.json @@ -5,64 +5,51 @@ "flag": "🇦🇹", "enabled": true }, - "header": { "header_slogan": "USB-Sticks testen", "btn_login": "Login", - "nav_how": "Wie es funktioniert", "nav_problem": "Warum es wichtig ist", "nav_features": "Funktionen", "nav_security": "Sicherheit", "nav_faq": "FAQ" }, - "brand": { "brand_wordmark": "{{primary_domain}}", "brand_subtitle": "USB-Sticks auf Fakes testen" }, - "footer": { "footer_imprint": "Impressum", "footer_privacy": "Datenschutz", "footer_copy": "© {year} {{primary_domain}}. Alle Rechte vorbehalten." }, - "fake_ui": { "error_fsapi_not_supported": "Die File System Access API wird von diesem Browser nicht unterstützt.", "error_no_directory_selected": "Kein Verzeichnis ausgewählt.", "error_no_space_detected": "Es konnte kein freier Speicher im gewählten Verzeichnis reserviert werden.", - "log_capacity_probe_start": "Ermittle verfügbaren Speicherplatz im gewählten Verzeichnis...", "log_capacity_probe_result": "Ermittelter für Tests nutzbarer Speicher: {size} (Schreibprobe).", - "log_quick_prepare": "Quick-Check: Vorbereitung... (Testgröße: {size})", "log_quick_verify_start": "Quick-Check: Schreiben abgeschlossen. Verifiziere Daten...", "log_quick_data_error": "Quick-Check: Datenfehler bei Byte {byte}.", "error_quick_data_error": "Datenfehler im Quick-Check bei Byte {byte}.", "log_quick_delete_warn": "Quick-Check: Konnte Testdatei nicht löschen (nicht kritisch).", "log_quick_success": "Quick-Check: Erfolgreich abgeschlossen.", - "log_bench_start": "Benchmark: Start – schreibe Testdatei ({size})...", "log_bench_read_start": "Benchmark: Lesen & Timing...", "log_bench_delete_warn": "Benchmark: Konnte Testdatei nicht löschen (nicht kritisch).", "log_bench_success": "Benchmark: Erfolgreich abgeschlossen.", - "log_wv_start": "Write/Verify: Start – {blocks} Blöcke à {size} (gesamt {total})...", "log_wv_block_start": "Write/Verify: Block {num}/{blocks} – {file}", "log_wv_data_error": "Write/Verify: Datenfehler in Block {num} bei Byte {byte}.", "error_wv_data_error": "Datenfehler in Block {num} bei Byte {byte}.", "log_wv_delete_warn": "Write/Verify: Konnte Blockdatei {file} nicht löschen (nicht kritisch).", "log_wv_success": "Write/Verify: Alle Blöcke erfolgreich verifiziert.", - "log_all_subtest_start": "All-Inclusive: Starte Teiltest \"{mode}\" ({num}/{total})...", "error_unknown_mode": "Unbekannter Modus: {mode}", - "log_fsapi_partial": "Dein Browser unterstützt die File System Access API nicht voll. Einige Funktionen sind deaktiviert.", - "selected_path_label": "USB-Ordner ausgewählt (Name: \"{name}\").", "selected_path_none": "Noch kein Verzeichnis gewählt.", - "status_ready": "Bereit. Wähle zuerst deinen USB-Stick aus.", "status_mode_none": "Kein Modus selektiert", "status_dir_selected": "USB-Verzeichnis ausgewählt. Wähle jetzt einen Testmodus.", @@ -72,13 +59,11 @@ "status_aborted": "Test wurde abgebrochen.", "status_error": "Fehler: {msg}", "status_error_unknown": "Unbekannter Fehler im Test.", - "overall_initial": "Noch kein Test durchgeführt.", "overall_running": "Test läuft...", "overall_done": "Browser-Test erfolgreich abgeschlossen.", "overall_aborted": "Test abgebrochen.", "overall_error": "Fehler im Browser-Test.", - "log_dir_selected": "Verzeichnis ausgewählt: {name}", "log_dir_reset": "Verzeichnisauswahl zurückgesetzt.", "log_pick_abort": "Verzeichnisauswahl abgebrochen.", @@ -90,20 +75,16 @@ "log_test_error": "Fehler im Test: {msg}", "log_test_error_unknown": "Unbekannter Fehler im Test.", "log_loaded": "USB-Browser-Test (fakecheck) geladen. Warte auf Verzeichnisauswahl und Modus.", - "mode_quick": "Quick-Check", "mode_benchmark": "Benchmark", "mode_writeverify": "Write & Verify", "mode_all": "All-Inclusive (alle Browser-Tests)", - "log_backend_save_error_status": "Backend: Konnte Ergebnis nicht speichern ({status}).", "log_backend_save_ok": "Backend: Testergebnis gespeichert{suffix}.", "log_backend_save_error": "Fehler beim Speichern im Backend: {msg}" }, - "serial": { "rating_label": "Bewertung", - "rating": { "ok": { "label": "Plausibel", @@ -126,17 +107,14 @@ "desc": "Bewertung nicht eindeutig möglich." } }, - "heading_input": "Eingabedaten", "heading_analysis": "Seriennummer-Analyse", "heading_consistency": "Hersteller-Konsistenz", - "input": { "manufacturer": "Hersteller (Angabe):", "vidpid": "VID/PID:", "vendor_detected": "Vendor aus VID:" }, - "analysis": { "serial": "Seriennummer:", "length": "Länge:", @@ -144,30 +122,223 @@ "score": "Score:", "issues": "Auffälligkeiten:" }, - "chars": "Zeichen", "none": "keine Angabe", - "issues_none": "Keine besonderen Auffälligkeiten.", - "vendor_detected": "{vendor} (VID {vid})", "vendor_unknown": "Unbekannter Hersteller für VID {vid}", "vendor_none": "Keine Vendor-ID angegeben", - "disclaimer": "Diese Einschätzung basiert auf Heuristiken und kann keine Echtheit garantieren.", - "error": { "no_serial": "Bitte gib eine Seriennummer ein.", "api": "Fehler bei der Prüfung: {msg}", "unknown": "Unerwartete Antwort vom Server." } }, - "pages": { "landing": { "meta": { "title": "{{primary_domain}} – USB-Sticks auf Fakes testen", "description": "USBCheck kombiniert einen schnellen Browser-Schnelltest mit einem professionellen Pro-Modus. So erkennst du gefälschte USB-Sticks, zu kleine echte Kapazität und langsame Billig-Controller – bevor deine Dateien verschwinden." + }, + "sections": { + "hero": { + "kicker": "Erkenne Fake-USB-Sticks, bevor du Daten verlierst", + "title": "Ist mein USB-Stick ein Fake?", + "lead": "USBCheck kombiniert einen schnellen Browser-Schnelltest mit einem professionellen Pro-Modus. So erkennst du gefälschte USB-Sticks, zu kleine echte Kapazität und langsame Billig-Controller – bevor deine Dateien verschwinden.", + "cta_quick": "Kostenlosen Schnelltest starten", + "cta_learn": "Mehr zu Free & Pro" + }, + "trust": { + "t1_title": "Keine Installation für Schnelltest", + "t1_text": "Browser-basierter Test direkt auf deinem Stick.", + "t2_title": "Echte Schreib- & Lesetests", + "t2_text": "Schreib-/Lesetests mit realen Daten – keine synthetischen Benchmarks.", + "t3_title": "Privacy first", + "t3_text": "Deine Testdaten bleiben lokal – Reports nur auf Wunsch." + }, + "quick": { + "label": "Schnelltest-Vorschau", + "title": "USB-Stick in unter 2 Minuten testen", + "badge_free": "Kostenlos", + "intro": "Der Schnelltest prüft eine definierte Datenmenge auf deinem Stick und misst:", + "li1": "Schreib- und Leserate", + "li2": "Datenintegrität (Hash-Vergleich)", + "li3": "Verdächtige Abbrüche oder Fehler", + "metric1_label": "Schreibleistung", + "metric1_value": "~ 75–120 MB/s*", + "metric2_label": "Integritätsprüfung", + "metric2_value": "512 MB Testdaten", + "footnote": "*Beispielwerte – deine Ergebnisse hängen von Stick, Port & System ab.", + "cta": "Zum kostenlosen Schnelltest", + "visual_title": "Schnelltest-Anzeige", + "visual_text": "So sieht die Quick-Check-Vorschau aus: Grün markiert stabile Daten, Orange warnt, wenn die Schreibrate einbricht.", + "visual_window": "Ergebnisfenster" + }, + "how": { + "kicker": "So funktioniert USBCheck", + "title": "Schnelltest im Browser, Pro-Modus mit Tiefenanalyse.", + "intro": "USBCheck wurde entwickelt, um zwei Welten zu verbinden: einen einfachen Schnelltest für alle und einen tiefgehenden Pro-Modus für Power-User, Techniker und Admins. Der Schnelltest läuft direkt im Browser, ohne Installation. Für den Pro-Modus wird ein kleines Helfer-Tool verwendet, das auf Wunsch F3- / badblocks-ähnliche Tests ausführt und damit Kapazitäts-Fakes sicher enttarnt.", + "step1_title": "Browser-Test starten", + "step1_text": "Du öffnest den Schnelltest unter {{primary_url}}/fakecheck/, wählst deinen USB-Stick bzw. einen Ordner darauf aus und definierst, wie viel Daten getestet werden sollen.", + "step2_title": "Schreib-, Lese- und Integritätsprüfung", + "step2_text": "Der Browser erstellt Testdateien, misst Schreib- und Leserate und vergleicht Hash-Werte, um Datenfehler zu erkennen – alles lokal und ohne Ãœbertragung deiner Inhalte.", + "step3_title": "Optional: Pro-Modus für Vollscan", + "step3_text": "Wer mehr wissen will, installiert das optionale Helfer-Tool. Dieses kann die gesamte Kapazität des Sticks prüfen, Fakes identifizieren und detaillierte Reports erzeugen – ideal für Refurbisher, IT-Abteilungen oder Labore.", + "side_title": "Free vs. Pro auf einen Blick", + "side_free": "Free Quick Check: Geschwindigkeit & Integritätstest im Browser – ideal für schnelle Einschätzungen.", + "side_pro": "Pro-Modus: Tiefenscan, Kapazitätsvalidierung, erweiterte Berichte und API-Integration für Unternehmen.", + "side_account": "Account & Login: Nach dem Login kannst du Tests speichern, Berichte exportieren und mehrere Geräte verwalten." + }, + "problem": { + "kicker": "Warum gefälschte USB-Sticks gefährlich sind", + "title": "Gefälschte USB-Sticks kosten Geld – und im schlimmsten Fall deine Daten.", + "p1": "Viele Billig-USB-Sticks werben mit unrealistisch hohen Kapazitäten. In Wahrheit wurde der Controller manipuliert: Der Stick meldet z. B. 256 GB, obwohl physisch nur 32 GB verbaut sind. Die Folge: Daten werden scheinbar korrekt kopiert, später aber stillschweigend überschrieben oder beschädigt.", + "p2": "USBCheck hilft dir, solche Fakes zu erkennen, bevor du sie produktiv einsetzt – egal ob du einzelne Sticks privat nutzt oder größere Chargen für dein Unternehmen prüfst.", + "card1_title": "Verlust wichtiger Dateien", + "card1_text": "Fotos, Projektdateien, Backups – alles kann betroffen sein, wenn der Stick weniger speichert als behauptet. Defekte Sektoren bleiben oft unbemerkt, bis es zu spät ist.", + "card2_title": "Kosten durch defekte Chargen", + "card2_text": "Unternehmen, Reseller und Agenturen verteilen USB-Sticks oft in großer Stückzahl. Fakes bedeuten Reklamationen, Imageschaden und erneute Produktionskosten.", + "card3_title": "Unsichere Performance", + "card3_text": "Langsame Controller, instabile Firmware und schwankende Schreibraten sind typisch für Fake-Sticks. Das erhöht das Risiko von Fehlern – besonders bei großen Dateien." + }, + "features": { + "kicker": "Free & Pro Features", + "title": "Starte mit dem kostenlosen Schnelltest – wechsle in den Pro-Modus, wenn du mehr brauchst.", + "intro": "USBCheck wächst mit deinen Anforderungen: Private Nutzer brauchen oft nur eine schnelle Einschätzung. Profis möchten tiefer einsteigen, Kapazitäten verifizieren und Reports archivieren. Genau dafür ist der Pro-Modus gedacht.", + "free_title": "Free Quick Check", + "free_badge": "Empfohlen für die meisten Nutzer", + "free_text": "Ideal für alle, die schnell prüfen möchten, ob ein USB-Stick zumindest grundlegend performant und stabil arbeitet – ganz ohne Installation.", + "free_li1": "• Browser-basierter Schnelltest direkt auf deinem Stick", + "free_li2": "• Schreib- und Lesegeschwindigkeit mit realen Testdaten", + "free_li3": "• Hash-basierte Integritätsprüfung einer Testmenge", + "free_li4": "• Auswahl verschiedener Teststufen (z. B. 200 MB, 2 GB)", + "free_li5": "• Keine Registrierung erforderlich", + "free_cta": "Kostenlosen Schnelltest starten", + "pro_title": "Pro Mode", + "pro_badge": "Für Power-User & Teams", + "pro_text": "Für alle, die volle Kontrolle brauchen: IT-Abteilungen, Techniker, Refurbisher, Labore oder Unternehmen, die regelmäßig größere Stick-Mengen testen.", + "pro_li1": "• Tiefenscan der gesamten Kapazität (ähnlich F3 / badblocks)", + "pro_li2": "• Erkennung von Kapazitäts-Fakes und defekten Bereichen", + "pro_li3": "• Detaillierte, speicherbare Testberichte (JSON, PDF)", + "pro_li4": "• Optional: API-Zugriff für automatisierte Testprozesse", + "pro_li5": "• Multi-Device- und Multi-User-Support (über Login-Bereich)", + "pro_note": "Der Pro-Modus erfordert ein kleines Helfer-Tool auf deinem System. Dieses arbeitet lokal und kann bei Bedarf mit deinem Account auf USBCheck verbunden werden." + }, + "security": { + "kicker": "Security & Privacy", + "title": "Privacy-first-Design: Deine Testdaten gehören dir.", + "intro": "USBCheck wurde von Anfang an so konzipiert, dass deine Daten geschützt bleiben. Der Browser-Schnelltest arbeitet ausschließlich mit Testdateien. Deine eigenen Dokumente, Bilder oder Backups werden weder gelesen noch übertragen. Im Pro-Modus hast du volle Kontrolle, ob und welche Reports mit deinem Account synchronisiert werden.", + "card1_title": "Local-only Tests", + "card1_text": "Alle Schreib- und Lesetests erfolgen lokal auf deinem USB-Stick. Der Browser greift nur auf die Testdateien zu – nicht auf deine privaten Inhalte.", + "card2_title": "Transparente Reports", + "card2_text": "Wenn du dich einloggst, kannst du Testberichte in deinem Account speichern, exportieren oder wieder löschen. Du entscheidest, welche Daten im System bleiben.", + "card3_title": "Schonend für deine Hardware", + "card3_text": "Der Schnelltest arbeitet mit moderaten Datenmengen, um unnötigen Verschleiß zu vermeiden. Der Pro-Modus warnt deutlich, wenn ein Vollscan mit hoher Schreiblast ausgeführt wird." + }, + "faq": { + "kicker": "FAQ", + "title": "Häufige Fragen zu USBCheck", + "intro": "Hier findest du Antworten auf häufig gestellte Fragen. Der FAQ-Bereich kann jederzeit erweitert werden, wenn neue Anwendungsfälle hinzukommen oder du Feedback von Nutzern erhältst.", + "q1": "Ist der Schnelltest wirklich komplett im Browser?", + "a1": "Ja. Der Schnelltest läuft vollständig im Browser und nutzt moderne Browser-APIs, um Testdateien auf deinem Stick zu schreiben und wieder auszulesen. Es wird nichts ohne deine Zustimmung hochgeladen.", + "q2": "Brauche ich ein Konto, um den Schnelltest zu benutzen?", + "a2": "Nein. Der kostenlose Schnelltest ist ohne Registrierung nutzbar. Ein Login ist nur notwendig, wenn du Testberichte speichern, mehrere Sticks verwalten oder den Pro-Modus nutzen möchtest.", + "q3": "Kann USBCheck jeden Fake-Stick sicher erkennen?", + "a3": "Kein Tool kann eine 100 %-Garantie geben. Der Pro-Modus mit Vollscan ist jedoch darauf ausgelegt, typische Fälschungsmuster (Manipulation der gemeldeten Kapazität, instabile Bereiche, Fehler ab einer bestimmten Füllmenge) sehr zuverlässig zu erkennen.", + "q4": "Wie fügt sich das Tool in mein bestehendes System ein?", + "a4": "USBCheck ist von Anfang an für Automatisierung gedacht. Ãœber den Pro-Modus und die geplante API kannst du Tests in bestehende Workflows integrieren – beispielsweise in Wareneingangsprüfungen oder Qualitätskontrollen." + } + } + }, + "fakecheck": { + "meta": { + "title": "FakeCheck – Browser-Test für USB-Sticks", + "description": "Der FakeCheck hilft dir, typische Fake-Sticks aufzuspüren: Browser-basierte Schreib-/Lesetests und Plausibilitätsprüfungen der nutzbaren Kapazität – ohne Installation." + }, + "sections": { + "hero": { + "kicker": "FakeCheck – Browser-Modus", + "title": "Ist mein USB-Stick fake?", + "lead": "Der FakeCheck hilft dir, typische Fake-Sticks aufzuspüren: Browser-basierte Schreib-/Lesetests und Plausibilitätsprüfungen der nutzbaren Kapazität – ohne Installation.", + "cta_start": "Browser-Test starten (Demo)", + "cta_back_home": "Zur Ãœbersicht zurück", + "hint": "Der FakeCheck im Browser arbeitet mit Testdateien und Lese-/Schreibmustern, die du in einem ausgewählten Ordner anlegst. Deine echten Dateien bleiben unangetastet." + }, + "capabilities": { + "title": "Was der Browser-Test leisten kann", + "point1_title": "Schreib-/Lesetest mit Testdateien", + "point1_text": "Der Browser legt Testdateien im gewählten Ordner an, misst Schreib- und Leseraten und prüft, ob gelesene Daten mit den geschriebenen Mustern übereinstimmen.", + "point2_title": "Plausibilitätscheck der Kapazität", + "point2_text": "Aus der Menge der erfolgreich geschriebenen und verifizierten Daten ergibt sich ein realistischer Eindruck, wie viel Nutzkapazität tatsächlich stabil ankommt.", + "point3_title": "JSON-Report für deine Dokumentation", + "point3_text": "Alle Ergebnisse werden in einem strukturierten JSON-Report gesammelt, den du speichern, hochladen oder für spätere Vergleiche nutzen kannst." + }, + "app": { + "title": "Browser-Testoberfläche (Preview)", + "intro": "Hier entsteht die eigentliche FakeCheck-Web-App: Auswahl des Testordners, Konfiguration der Testmenge, Fortschrittsanzeige und Ergebnisübersicht. Aktuell zeigt der Button oben nur eine Demo-Ausgabe.", + "point1": "Quick-Test mit kleiner Datenmenge.", + "point2": "Light-Benchmark: Schreib-/Lesegeschwindigkeit über begrenzte Zeit.", + "point3": "Write/Verify: Testdateien schreiben und direkt wieder verifizieren." + }, + "result": { + "title": "Demo-Ausgabe des Browser-Tests", + "hint": "Diese Ausgabe dient nur als Vorschau. Später wird hier der echte JSON-Report aus dem Browser-Test angezeigt." + } + } + }, + "login": { + "meta": { + "title": "Login – {{primary_domain}}", + "description": "Melde dich bei {{primary_domain}} an, um Tests zu speichern, den Pro-Modus zu nutzen und mehrere Geräte zu verwalten." + }, + "sections": { + "auth": { + "kicker": "Account & Login", + "title": "Melde dich bei USBCheck an", + "intro": "Mit einem Account kannst du Tests speichern, Reports exportieren und den Pro-Modus auf mehreren Geräten nutzen. Die Registrierung ist kostenlos – du kannst später jederzeit auf Pro upgraden.", + "tab_login": "Login", + "tab_register": "Registrieren", + "login_title": "Login", + "login_text": "Melde dich mit deiner E-Mail-Adresse und deinem Passwort an.", + "login_email_label": "E-Mail-Adresse", + "login_password_label": "Passwort", + "login_submit": "Einloggen", + "login_forgot": "Passwort vergessen?", + "register_title": "Kostenlos registrieren", + "register_text": "Erstelle einen kostenlosen Account, um Tests zu speichern, Berichte zu exportieren und den Pro-Modus später freizuschalten.", + "register_name_label": "Name", + "register_email_label": "E-Mail-Adresse", + "register_password_label": "Passwort", + "register_submit": "Account erstellen", + "register_hint": "Durch die Registrierung akzeptierst du die Datenschutzerklärung und das Impressum von USBCheck." + } + } + }, + "dashboard": { + "meta": { + "title": "Dashboard – {{primary_domain}}", + "description": "Verwalte deine USB-Tests, Geräte und Pro-Modus-Einstellungen in deinem persönlichen Dashboard." + }, + "sections": { + "main": { + "kicker": "Dashboard", + "title": "Willkommen", + "intro": "Hier kannst du deine USB-Tests verwalten, Geräte übersichtlich organisieren und später den Pro-Modus aktivieren. Dieser Bereich ist aktuell noch im Aufbau – du bekommst aber schon einen ersten Ãœberblick.", + "plan_label": "Aktueller Plan", + "card_tests_title": "Letzte Tests", + "card_tests_text": "Hier werden später deine letzten Schnelltests und Pro-Scans angezeigt – inklusive Status, Geschwindigkeit und Integritätsprüfung.", + "card_tests_empty": "Noch keine Testdaten vorhanden. Starte einen ersten Test über den Browser oder den Pro-Modus.", + "card_devices_title": "Deine USB-Geräte", + "card_devices_text": "Später kannst du hier deine getesteten Sticks verwalten: Hersteller, Modell, Seriennummer und erkannte Kapazität.", + "card_devices_empty": "Noch keine Geräte gespeichert. Nach deinen ersten Tests kannst du USB-Sticks hier als Geräte anlegen.", + "card_next_title": "Nächste Schritte", + "card_next_text": "USBCheck ist noch im Aufbau. Du gehörst zu den ersten Nutzern – später findest du hier Pro-Optionen, API-Zugänge und Detail-Reports.", + "card_next_item1": "• Browser-FakeCheck testen und Feedback geben", + "card_next_item2": "• Pro-Modus-Features definieren (z. B. Vollscan, Reports, API)", + "card_next_item3": "• Accounts & SSO (my-log.in) finalisieren", + "card_next_cta": "Zum Browser-FakeCheck" + } } } } diff --git a/public/assets/i18n/dk.json b/public/assets/i18n/dk.json index 096cb0d..5dab194 100644 --- a/public/assets/i18n/dk.json +++ b/public/assets/i18n/dk.json @@ -5,64 +5,51 @@ "flag": "🇩🇰", "enabled": true }, - "header": { "header_slogan": "Test USB-drev", "btn_login": "Login", - "nav_how": "SÃ¥dan fungerer det", "nav_problem": "Hvorfor det er vigtigt", "nav_features": "Funktioner", "nav_security": "Sikkerhed", "nav_faq": "FAQ" }, - "brand": { "brand_wordmark": "{{primary_domain}}", "brand_subtitle": "Tjek USB-drev for forfalskninger" }, - "footer": { "footer_imprint": "Imprint", "footer_privacy": "Privatliv", "footer_copy": "© {year} {{primary_domain}}. Alle rettigheder forbeholdes." }, - "fake_ui": { "error_fsapi_not_supported": "Denne browser understøtter ikke File System Access API.", "error_no_directory_selected": "Ingen mappe valgt.", "error_no_space_detected": "Det var ikke muligt at reservere ledig plads i den valgte mappe.", - "log_capacity_probe_start": "Finder ledig plads i den valgte mappe...", "log_capacity_probe_result": "Registreret plads der kan bruges til tests: {size} (skriveprobe).", - "log_quick_prepare": "Quick-check: forbereder... (teststørrelse: {size})", "log_quick_verify_start": "Quick-check: skrivning færdig. Verificerer data...", "log_quick_data_error": "Quick-check: datafejl ved byte {byte}.", "error_quick_data_error": "Datafejl i quick-check ved byte {byte}.", "log_quick_delete_warn": "Quick-check: kunne ikke slette testfil (ikke kritisk).", "log_quick_success": "Quick-check: gennemført med succes.", - "log_bench_start": "Benchmark: start – skriver testfil ({size})...", "log_bench_read_start": "Benchmark: læser og mÃ¥ler...", "log_bench_delete_warn": "Benchmark: kunne ikke slette testfil (ikke kritisk).", "log_bench_success": "Benchmark: afsluttet med succes.", - "log_wv_start": "Write/Verify: start – {blocks} blokke á {size} (i alt {total})...", "log_wv_block_start": "Write/Verify: blok {num}/{blocks} – {file}", "log_wv_data_error": "Write/Verify: datafejl i blok {num} ved byte {byte}.", "error_wv_data_error": "Datafejl i blok {num} ved byte {byte}.", "log_wv_delete_warn": "Write/Verify: kunne ikke slette blokfilen {file} (ikke kritisk).", "log_wv_success": "Write/Verify: alle blokke verificeret med succes.", - "log_all_subtest_start": "All-inclusive: starter deltest \"{mode}\" ({num}/{total})...", "error_unknown_mode": "Ukendt tilstand: {mode}", - "log_fsapi_partial": "Din browser understøtter ikke File System Access API fuldt ud. Visse funktioner er deaktiveret.", - "selected_path_label": "USB-mappe valgt (navn: \"{name}\").", "selected_path_none": "Der er endnu ikke valgt en mappe.", - "status_ready": "Klar. Vælg først dit USB-drev.", "status_mode_none": "Ingen tilstand valgt", "status_dir_selected": "USB-mappe valgt. Vælg nu en testtilstand.", @@ -72,13 +59,11 @@ "status_aborted": "Testen blev afbrudt.", "status_error": "Fejl: {msg}", "status_error_unknown": "Ukendt fejl i testen.", - "overall_initial": "Der er endnu ikke kørt en test.", "overall_running": "Test kører...", "overall_done": "Browser-test gennemført med succes.", "overall_aborted": "Test afbrudt.", "overall_error": "Fejl i browser-testen.", - "log_dir_selected": "Mappe valgt: {name}", "log_dir_reset": "Mappevalg nulstillet.", "log_pick_abort": "Mappevalg annulleret.", @@ -90,20 +75,16 @@ "log_test_error": "Fejl under testen: {msg}", "log_test_error_unknown": "Ukendt fejl under testen.", "log_loaded": "USB-browser-test (fakecheck) indlæst. Venter pÃ¥ mappevalg og tilstand.", - "mode_quick": "Quick-Check", "mode_benchmark": "Benchmark", "mode_writeverify": "Write & Verify", "mode_all": "All-Inclusive (alle browser-tests)", - "log_backend_save_error_status": "Backend: kunne ikke gemme resultat ({status}).", "log_backend_save_ok": "Backend: testresultat gemt{suffix}.", "log_backend_save_error": "Fejl ved lagring i backend: {msg}" }, - "serial": { "rating_label": "Vurdering", - "rating": { "ok": { "label": "Plausibel", @@ -126,17 +107,14 @@ "desc": "Det var ikke muligt at give en entydig vurdering." } }, - "heading_input": "Indtastede data", "heading_analysis": "Analyse af serienummer", "heading_consistency": "Sammenhæng til producent", - "input": { "manufacturer": "Producent (angivet):", "vidpid": "VID/PID:", "vendor_detected": "Producent ud fra VID:" }, - "analysis": { "serial": "Serienummer:", "length": "Længde:", @@ -144,30 +122,223 @@ "score": "Score:", "issues": "Afvigelser:" }, - "chars": "tegn", "none": "ingen oplysning", - "issues_none": "Ingen særlige afvigelser.", - "vendor_detected": "{vendor} (VID {vid})", "vendor_unknown": "Ukendt producent for VID {vid}", "vendor_none": "Ingen vendor-ID angivet", - "disclaimer": "Denne vurdering er heuristisk og kan ikke garantere ægthed.", - "error": { "no_serial": "Angiv venligst et serienummer.", "api": "Fejl under kontrollen: {msg}", "unknown": "Uventet svar fra serveren." } }, - "pages": { "landing": { "meta": { - "title": "{{primary_domain}} – Tjek USB-drev for forfalskninger", - "description": "USBCheck kombinerer en hurtig browser-test med en professionel Pro Mode, sÃ¥ du opdager falske USB-drev, for lille reel kapacitet og langsomme controllere, før dine filer forsvinder." + "title": "{{primary_domain}} – Test dine USB-drev for forfalskninger", + "description": "USBCheck kombinerer et hurtigt browser-tjek med en professionel Pro-tilstand, sÃ¥ du kan afsløre falske drev, manglende kapacitet og langsomme controllere, før filerne forsvinder." + }, + "sections": { + "hero": { + "kicker": "Afslør falske USB-drev, før du mister data", + "title": "Er mit USB-drev et falsk?", + "lead": "USBCheck kombinerer et hurtigt browser-tjek med en professionel Pro-tilstand, sÃ¥ du kan afsløre falske drev, manglende kapacitet og langsomme controllere, før filerne forsvinder.", + "cta_quick": "Start det gratis hurtigtjek", + "cta_learn": "Mere om Free & Pro" + }, + "trust": { + "t1_title": "Ingen installation til hurtigtjekket", + "t1_text": "Browserbaseret test direkte pÃ¥ dit drev.", + "t2_title": "Ægte skrive- og læsetests", + "t2_text": "Test med rigtige data – ikke syntetiske benchmarks.", + "t3_title": "Privacy først", + "t3_text": "Dine testdata bliver pÃ¥ enheden – du uploader kun rapporter, hvis du ønsker det." + }, + "quick": { + "label": "ForhÃ¥ndsvisning af hurtigtjekket", + "title": "Test et USB-drev pÃ¥ under 2 minutter", + "badge_free": "Gratis", + "intro": "Hurtigtjekket skriver en defineret datamængde pÃ¥ dit drev og mÃ¥ler:", + "li1": "Skrive- og læsehastighed", + "li2": "Dataintegritet (hash-sammenligning)", + "li3": "Mistænkelige afbrydelser eller fejl", + "metric1_label": "Skriveydelse", + "metric1_value": "~ 75–120 MB/s*", + "metric2_label": "Integritetstjek", + "metric2_value": "512 MB testdata", + "footnote": "*Eksempelværdier – resultater afhænger af drev, port og system.", + "cta": "GÃ¥ til det gratis hurtigtjek", + "visual_title": "Visning af hurtigtjek", + "visual_text": "SÃ¥dan ser Quick Check-previewet ud: grønt markerer stabile data, orange advarer nÃ¥r skrivehastigheden falder.", + "visual_window": "Resultatvindue" + }, + "how": { + "kicker": "SÃ¥dan fungerer USBCheck", + "title": "Hurtigtjek i browseren, Pro-tilstand med dybdegÃ¥ende analyse.", + "intro": "USBCheck er bygget til at forene to verdener: et simpelt hurtigtjek for alle og en dyb Pro-tilstand til power users, teknikere og administratorer. Hurtigtjekket kører direkte i browseren uden installation. Pro-tilstanden bruger et lille hjælpeværktøj, der kan køre F3-/badblocks-lignende tests for at afsløre kapacitetsfalske.", + "step1_title": "Start browser-testen", + "step1_text": "Ã…bn hurtigtjekket pÃ¥ {{primary_url}}/fakecheck/, vælg dit USB-drev eller en mappe og bestem hvor mange data der skal testes.", + "step2_title": "Skrive-, læse- og integritetstest", + "step2_text": "Browseren opretter testfiler, mÃ¥ler skrive-/læsehastighed og sammenligner hashes for at finde fejl – alt sker lokalt uden upload af dit indhold.", + "step3_title": "Valgfrit: Pro-tilstand for fuld scanning", + "step3_text": "Har du brug for flere detaljer, installerer du hjælpeværktøjet. Det kan scanne hele kapaciteten, finde falske og generere detaljerede rapporter – ideelt for refurbishere, IT-teams eller laboratorier.", + "side_title": "Free vs. Pro pÃ¥ et øjeblik", + "side_free": "Free Quick Check: browserbaseret hastigheds- og integritetstest – perfekt til hurtige vurderinger.", + "side_pro": "Pro-tilstand: dyb scanning, kapacitetsvalidering, udvidede rapporter og API-integration til virksomheder.", + "side_account": "Konto & login: efter login kan du gemme tests, eksportere rapporter og styre flere enheder." + }, + "problem": { + "kicker": "Hvorfor falske USB-drev er farlige", + "title": "Falske drev koster penge – og i værste fald dine data.", + "p1": "Mange billige drev markedsfører urealistisk kapacitet. Controlleren manipuleres: et drev lover f.eks. 256 GB selv om der fysisk kun sidder 32 GB. Filerne ser ud til at blive kopieret, men overskrives eller korrumperes senere.", + "p2": "USBCheck hjælper dig med at opdage falske, før du tager dem i brug – uanset om det er privat eller til større partier i virksomheden.", + "card1_title": "Tab af vigtige filer", + "card1_text": "Fotos, projekter, backups – alt er i fare, hvis drevet gemmer mindre end lovet. Fejlende sektorer opdages ofte først, nÃ¥r skaden er sket.", + "card2_title": "Omkostninger ved dÃ¥rlige partier", + "card2_text": "Virksomheder og forhandlere uddeler USB-drev i store mængder. Falske betyder reklamationer, image-tab og ny produktion.", + "card3_title": "Ustabil ydeevne", + "card3_text": "Langsomme controllere, ustabil firmware og svingende skrivehastigheder er typiske for falske drev og øger risikoen for fejl – især ved store filer." + }, + "features": { + "kicker": "Free & Pro-funktioner", + "title": "Start med det gratis hurtigtjek – skift til Pro nÃ¥r du har behov.", + "intro": "USBCheck vokser med dine behov: private brugere behøver ofte blot en hurtig vurdering, mens professionelle vil gÃ¥ i dybden, validere kapacitet og gemme rapporter. Derfor findes Pro-tilstanden.", + "free_title": "Free Quick Check", + "free_badge": "Anbefalet for de fleste", + "free_text": "Perfekt til alle, der hurtigt vil se om et drev kører rimeligt hurtigt og stabilt – helt uden installation.", + "free_li1": "• Browserbaseret hurtigtjek direkte pÃ¥ dit drev", + "free_li2": "• Skrive-/læsehastighed med rigtige testdata", + "free_li3": "• Hash-baseret integritetstjek af en datamængde", + "free_li4": "• Vælg mellem flere testniveauer (f.eks. 200 MB, 2 GB)", + "free_li5": "• Ingen registrering nødvendig", + "free_cta": "Start gratis hurtigtjek", + "pro_title": "Pro-tilstand", + "pro_badge": "Til power users & teams", + "pro_text": "Til IT-afdelinger, teknikere, refurbishere eller virksomheder, der tester mange drev og vil have fuld kontrol.", + "pro_li1": "• Dyb scanning af hele kapaciteten (á la F3/badblocks)", + "pro_li2": "• Finder kapacitetsfalske og defekte omrÃ¥der", + "pro_li3": "• Detaljerede rapporter, der kan gemmes (JSON, PDF)", + "pro_li4": "• Valgfri API-adgang til automatiserede processer", + "pro_li5": "• Multi-device og multi-user support via loginomrÃ¥det", + "pro_note": "Pro-tilstanden kræver et lille hjælpeprogram pÃ¥ systemet. Det kører lokalt og kan kobles til din USBCheck-konto efter behov." + }, + "security": { + "kicker": "Sikkerhed & privatliv", + "title": "Privacy-first design: dine testdata tilhører dig.", + "intro": "USBCheck er designet til at beskytte dine data. Browserens hurtigtjek bruger kun testfiler; dine egne dokumenter, billeder eller backups læses eller uploades ikke. I Pro-tilstanden bestemmer du selv om – og hvilke – rapporter der synkroniseres med kontoen.", + "card1_title": "Kun lokale tests", + "card1_text": "Alle skrive-/læsetests foregÃ¥r lokalt pÃ¥ USB-drevet. Browseren rører kun testfilerne – ikke dine private filer.", + "card2_title": "Gennemsigtige rapporter", + "card2_text": "Efter login kan du gemme rapporter i din konto, eksportere dem eller slette dem igen. Du bestemmer, hvad der bliver i systemet.", + "card3_title": "SkÃ¥nsom mod hardwaren", + "card3_text": "Hurtigtjekket bruger moderate datamængder for at undgÃ¥ unødigt slid. Pro-tilstanden advarer tydeligt, nÃ¥r der køres en fuld, skrivintensiv scanning." + }, + "faq": { + "kicker": "FAQ", + "title": "Ofte stillede spørgsmÃ¥l om USBCheck", + "intro": "Her finder du svar pÃ¥ de mest almindelige spørgsmÃ¥l. Udvid FAQ’en nÃ¥r nye use cases dukker op eller du fÃ¥r feedback fra brugere.", + "q1": "ForegÃ¥r hurtigtjekket helt i browseren?", + "a1": "Ja. Testen kører udelukkende i browseren og bruger moderne API’er til at skrive og læse testfiler pÃ¥ dit drev. Intet uploades uden dit samtykke.", + "q2": "Skal jeg have en konto for at bruge hurtigtjekket?", + "a2": "Nej. Det gratis hurtigtjek kræver ingen registrering. Login er kun nødvendigt, hvis du vil gemme rapporter, styre flere drev eller bruge Pro-tilstanden.", + "q3": "Kan USBCheck fange alle falske drev?", + "a3": "Ingen løsning kan love 100 %. Men Pro-tilstanden med fuld scanning er designet til sikkert at opdage typiske mønstre: rapporteret vs. fysisk kapacitet, ustabile omrÃ¥der eller fejl ved bestemte udfyldningsgrader.", + "q4": "Hvordan passer værktøjet ind i mit workflow?", + "a4": "USBCheck er lavet til automatisering. Med Pro-tilstanden og den planlagte API kan du integrere test i eksisterende flows, fx varemodtagelse eller kvalitetssikring." + } + } + }, + "fakecheck": { + "meta": { + "title": "FakeCheck – Browser-test for USB-drev", + "description": "FakeCheck hjælper dig med at afsløre typiske falske drev: browserbaserede skrive-/læsetests og plausibilitetskontrol af den brugbare kapacitet – helt uden installation." + }, + "sections": { + "hero": { + "kicker": "FakeCheck – browsertilstand", + "title": "Er mit USB-drev falsk?", + "lead": "FakeCheck hjælper dig med at afsløre typiske falske drev: browserbaserede skrive-/læsetests og kapacitetstjek uden installation.", + "cta_start": "Start browser-test (demo)", + "cta_back_home": "Tilbage til oversigten", + "hint": "FakeCheck i browseren arbejder med testfiler og læse-/skrivemønstre i en valgt mappe. Dine rigtige filer forbliver uberørte." + }, + "capabilities": { + "title": "Hvad browser-testen kan", + "point1_title": "Skrive-/læsetest med testfiler", + "point1_text": "Browseren opretter testfiler i den valgte mappe, mÃ¥ler skrive-/læsehastigheder og tjekker om de læste data matcher mønstrene.", + "point2_title": "Plausibilitetstjek af kapacitet", + "point2_text": "Mængden af data der skrives og verificeres giver et realistisk billede af, hvor meget brugbar kapacitet der faktisk er stabil.", + "point3_title": "JSON-rapport til dokumentation", + "point3_text": "Alle resultater samles i en struktureret JSON-rapport, som du kan gemme, uploade eller genbruge senere." + }, + "app": { + "title": "Browser-test interface (preview)", + "intro": "Her kommer selve FakeCheck web-appen: vælg mappe, konfigurér datamængde, se fremdrift og resultater. Foreløbig viser knappen ovenfor blot en demo-output.", + "point1": "Quick-test med begrænset datamængde.", + "point2": "Let benchmark: skrive-/læsehastighed over kort tid.", + "point3": "Write/Verify: skriv testfiler og verificér dem med det samme." + }, + "result": { + "title": "Demo-output fra browser-testen", + "hint": "Denne visning er kun en forhÃ¥ndsvisning. Senere vises den rigtige JSON-rapport fra browser-testen her." + } + } + }, + "login": { + "meta": { + "title": "Login – {{primary_domain}}", + "description": "Log ind pÃ¥ {{primary_domain}} for at gemme tests, bruge Pro-tilstand og styre flere enheder." + }, + "sections": { + "auth": { + "kicker": "Konto & login", + "title": "Log ind pÃ¥ USBCheck", + "intro": "Med en konto kan du gemme tests, eksportere rapporter og bruge Pro-tilstand pÃ¥ flere enheder. Registrering er gratis – opgrader til Pro nÃ¥r som helst.", + "tab_login": "Login", + "tab_register": "Registrer", + "login_title": "Login", + "login_text": "Log ind med din e-mailadresse og adgangskode.", + "login_email_label": "E-mail", + "login_password_label": "Adgangskode", + "login_submit": "Log ind", + "login_forgot": "Glemt adgangskode?", + "register_title": "Gratis registrering", + "register_text": "Opret en gratis konto for at gemme tests, eksportere rapporter og lÃ¥se op for Pro-tilstanden senere.", + "register_name_label": "Navn", + "register_email_label": "E-mail", + "register_password_label": "Adgangskode", + "register_submit": "Opret konto", + "register_hint": "Ved at registrere dig accepterer du USBChecks privatlivspolitik og juridiske oplysninger." + } + } + }, + "dashboard": { + "meta": { + "title": "Dashboard – {{primary_domain}}", + "description": "Administrér dine USB-tests, enheder og Pro-indstillinger i dit personlige dashboard." + }, + "sections": { + "main": { + "kicker": "Dashboard", + "title": "Velkommen", + "intro": "Administrér dine USB-tests, hold styr pÃ¥ enhederne og aktivér snart Pro-tilstanden. OmrÃ¥det er stadig under opbygning, men giver allerede et første indblik.", + "plan_label": "Aktuel plan", + "card_tests_title": "Seneste tests", + "card_tests_text": "Dine seneste hurtigtjek og Pro-scanninger vises her – med status, hastighed og integritet.", + "card_tests_empty": "Ingen testdata endnu. Start din første test via browseren eller Pro-tilstanden.", + "card_devices_title": "Dine USB-enheder", + "card_devices_text": "Snart kan du administrere dine testede drev her: producent, model, serienummer og registreret kapacitet.", + "card_devices_empty": "Ingen enheder gemt endnu. Efter dine første tests kan du tilføje dem her.", + "card_next_title": "Næste skridt", + "card_next_text": "USBCheck er stadig i udvikling. Du er blandt de første brugere – senere finder du Pro-muligheder, API-adgang og detaljerede rapporter her.", + "card_next_item1": "• Test browser-FakeCheck og giv feedback", + "card_next_item2": "• Definér Pro-funktioner (fx fuld scanning, rapporter, API)", + "card_next_item3": "• Færdiggør konti og SSO (my-log.in)", + "card_next_cta": "GÃ¥ til browser-FakeCheck" + } } } } diff --git a/public/assets/i18n/es.json b/public/assets/i18n/es.json index 530978b..3f1a4e9 100644 --- a/public/assets/i18n/es.json +++ b/public/assets/i18n/es.json @@ -5,64 +5,51 @@ "flag": "🇪🇸", "enabled": true }, - "header": { "header_slogan": "Prueba memorias USB", "btn_login": "Iniciar sesión", - "nav_how": "Cómo funciona", "nav_problem": "Por qué importa", "nav_features": "Funciones", "nav_security": "Seguridad", "nav_faq": "FAQ" }, - "brand": { "brand_wordmark": "{{primary_domain}}", "brand_subtitle": "Detecta memorias USB falsas" }, - "footer": { "footer_imprint": "Aviso legal", "footer_privacy": "Privacidad", "footer_copy": "© {year} {{primary_domain}}. Todos los derechos reservados." }, - "fake_ui": { "error_fsapi_not_supported": "Este navegador no admite la File System Access API.", "error_no_directory_selected": "No se ha seleccionado ninguna carpeta.", "error_no_space_detected": "No fue posible reservar espacio libre en la carpeta elegida.", - "log_capacity_probe_start": "Comprobando el espacio disponible en la carpeta seleccionada...", "log_capacity_probe_result": "Espacio utilizable detectado para las pruebas: {size} (escritura de prueba).", - "log_quick_prepare": "Quick-Check: preparando… (tamaño del test: {size})", "log_quick_verify_start": "Quick-Check: escritura completada. Verificando datos...", "log_quick_data_error": "Quick-Check: error de datos en el byte {byte}.", "error_quick_data_error": "Error de datos en el Quick-Check en el byte {byte}.", "log_quick_delete_warn": "Quick-Check: no se pudo borrar el archivo de prueba (no crítico).", "log_quick_success": "Quick-Check finalizado correctamente.", - "log_bench_start": "Benchmark: inicio – escribiendo archivo de prueba ({size})...", "log_bench_read_start": "Benchmark: lectura y cronometraje...", "log_bench_delete_warn": "Benchmark: no se pudo borrar el archivo de prueba (no crítico).", "log_bench_success": "Benchmark completado con éxito.", - "log_wv_start": "Write/Verify: inicio – {blocks} bloques de {size} (total {total})...", "log_wv_block_start": "Write/Verify: bloque {num}/{blocks} – {file}", "log_wv_data_error": "Write/Verify: error de datos en el bloque {num} en el byte {byte}.", "error_wv_data_error": "Error de datos en el bloque {num} en el byte {byte}.", "log_wv_delete_warn": "Write/Verify: no se pudo borrar el archivo {file} (no crítico).", "log_wv_success": "Write/Verify: todos los bloques verificados correctamente.", - "log_all_subtest_start": "All-Inclusive: iniciando subtest \"{mode}\" ({num}/{total})...", "error_unknown_mode": "Modo desconocido: {mode}", - "log_fsapi_partial": "Tu navegador no admite completamente la File System Access API. Algunas funciones se desactivarán.", - "selected_path_label": "Carpeta USB seleccionada (nombre: \"{name}\").", "selected_path_none": "Aún no se ha elegido carpeta.", - "status_ready": "Listo. Primero selecciona tu memoria USB.", "status_mode_none": "Ningún modo seleccionado", "status_dir_selected": "Carpeta USB seleccionada. Elige ahora un modo.", @@ -72,13 +59,11 @@ "status_aborted": "Prueba cancelada.", "status_error": "Error: {msg}", "status_error_unknown": "Error desconocido durante la prueba.", - "overall_initial": "Aún no se ha realizado ninguna prueba.", "overall_running": "Prueba en curso…", "overall_done": "Prueba del navegador completada con éxito.", "overall_aborted": "Prueba cancelada.", "overall_error": "Error en la prueba del navegador.", - "log_dir_selected": "Carpeta seleccionada: {name}", "log_dir_reset": "Selección de carpeta reiniciada.", "log_pick_abort": "Selección de carpeta cancelada.", @@ -90,20 +75,16 @@ "log_test_error": "Error durante la prueba: {msg}", "log_test_error_unknown": "Error desconocido durante la prueba.", "log_loaded": "Test del navegador USB (fakecheck) cargado. Esperando carpeta y modo.", - "mode_quick": "Quick-Check", "mode_benchmark": "Benchmark", "mode_writeverify": "Write & Verify", "mode_all": "All-Inclusive (todas las pruebas)", - "log_backend_save_error_status": "Backend: no se pudo guardar el resultado ({status}).", "log_backend_save_ok": "Backend: resultado guardado{suffix}.", "log_backend_save_error": "Error al guardar en el backend: {msg}" }, - "serial": { "rating_label": "Valoración", - "rating": { "ok": { "label": "Plausible", @@ -126,17 +107,14 @@ "desc": "No se pudo determinar una valoración clara." } }, - "heading_input": "Datos introducidos", "heading_analysis": "Análisis del número de serie", "heading_consistency": "Coherencia del fabricante", - "input": { "manufacturer": "Fabricante (dato del usuario):", "vidpid": "VID/PID:", "vendor_detected": "Fabricante detectado por la VID:" }, - "analysis": { "serial": "Número de serie:", "length": "Longitud:", @@ -144,30 +122,223 @@ "score": "Puntuación:", "issues": "Observaciones:" }, - "chars": "caracteres", "none": "sin dato", - "issues_none": "Sin observaciones destacables.", - "vendor_detected": "{vendor} (VID {vid})", "vendor_unknown": "Fabricante desconocido para la VID {vid}", "vendor_none": "No se indicó VID", - "disclaimer": "Esta valoración es heurística y no garantiza la autenticidad.", - "error": { "no_serial": "Introduce un número de serie.", "api": "Error durante la verificación: {msg}", "unknown": "Respuesta inesperada del servidor." } }, - "pages": { "landing": { "meta": { - "title": "{{primary_domain}} – Prueba tus USB contra falsificaciones", - "description": "USBCheck combina un test rápido en el navegador con un modo Pro profesional para detectar memorias falsas antes de perder tus datos." + "title": "{{primary_domain}} – Prueba unidades USB contra falsificaciones", + "description": "USBCheck combina un control rápido en el navegador con un modo Pro profesional para detectar memorias falsas, capacidad perdida y controladores lentos antes de que desaparezcan tus archivos." + }, + "sections": { + "hero": { + "kicker": "Detecta memorias USB falsas antes de perder datos", + "title": "¿Mi memoria USB es falsa?", + "lead": "USBCheck combina un control rápido en el navegador con un modo Pro profesional para detectar memorias falsas, capacidad perdida y controladores lentos antes de que desaparezcan tus archivos.", + "cta_quick": "Iniciar el test rápido gratuito", + "cta_learn": "Más sobre Free & Pro" + }, + "trust": { + "t1_title": "Sin instalación para el test rápido", + "t1_text": "Prueba basada en navegador directamente en tu unidad.", + "t2_title": "Pruebas reales de lectura y escritura", + "t2_text": "Pruebas con datos reales, no benchmarks sintéticos.", + "t3_title": "Privacidad primero", + "t3_text": "Tus datos de prueba se quedan locales; solo subes informes si quieres." + }, + "quick": { + "label": "Vista previa del test rápido", + "title": "Prueba una memoria USB en menos de 2 minutos", + "badge_free": "Gratis", + "intro": "El test rápido escribe un volumen definido de datos en tu unidad y mide:", + "li1": "Velocidad de escritura y lectura", + "li2": "Integridad de datos (comparación hash)", + "li3": "Abortos o errores sospechosos", + "metric1_label": "Rendimiento de escritura", + "metric1_value": "~ 75–120 MB/s*", + "metric2_label": "Prueba de integridad", + "metric2_value": "512 MB de datos de prueba", + "footnote": "*Valores de ejemplo; tus resultados dependen de la unidad, el puerto y el sistema.", + "cta": "Ir al test rápido gratuito", + "visual_title": "Pantalla del test rápido", + "visual_text": "Así se ve la vista previa del Quick Check: verde marca datos estables y naranja avisa cuando la velocidad cae.", + "visual_window": "Ventana de resultados" + }, + "how": { + "kicker": "Cómo funciona USBCheck", + "title": "Test rápido en el navegador, modo Pro con análisis profundo.", + "intro": "USBCheck se diseñó para unir dos mundos: un test rápido sencillo para todos y un modo Pro en profundidad para usuarios avanzados, técnicos y administradores. El test rápido se ejecuta directamente en el navegador sin instalación. El modo Pro usa una herramienta auxiliar que puede realizar pruebas tipo F3/badblocks para desenmascarar falsos de capacidad.", + "step1_title": "Inicia el test en el navegador", + "step1_text": "Abre el test rápido en {{primary_url}}/fakecheck/, selecciona tu memoria USB o una carpeta sobre ella y define cuántos datos quieres probar.", + "step2_title": "Pruebas de escritura, lectura e integridad", + "step2_text": "El navegador crea archivos de prueba, mide la velocidad de escritura/lectura y compara hashes para detectar errores, todo local sin subir tu contenido.", + "step3_title": "Opcional: modo Pro para escaneo completo", + "step3_text": "Si necesitas más detalle, instala la herramienta auxiliar opcional. Comprueba toda la capacidad, detecta falsificaciones y genera informes detallados: ideal para reacondicionadores, equipos de TI o laboratorios.", + "side_title": "Free vs. Pro de un vistazo", + "side_free": "Free Quick Check: Test de velocidad e integridad en el navegador, ideal para valoraciones rápidas.", + "side_pro": "Modo Pro: Escaneo profundo, validación de capacidad, informes ampliados e integración API para empresas.", + "side_account": "Cuenta & login: Tras iniciar sesión puedes guardar tests, exportar informes y gestionar varios dispositivos." + }, + "problem": { + "kicker": "Por qué las USB falsas son peligrosas", + "title": "Las memorias falsas cuestan dinero y, en el peor caso, tus datos.", + "p1": "Muchas memorias baratas anuncian capacidades irreales. El controlador se manipula: el USB afirma tener 256 GB aunque solo haya 32 GB físicos. Los archivos parecen copiarse bien pero luego se sobrescriben o se dañan en silencio.", + "p2": "USBCheck te ayuda a detectar estos falsos antes de confiar en ellos, ya sea para uso privado o para revisar lotes completos en tu empresa.", + "card1_title": "Pérdida de archivos importantes", + "card1_text": "Fotos, proyectos, copias de seguridad... todo está en riesgo cuando la unidad guarda menos de lo prometido. Los sectores defectuosos pasan desapercibidos hasta que ya es tarde.", + "card2_title": "Costes por tandas defectuosas", + "card2_text": "Empresas, revendedores y agencias reparten memorias en grandes cantidades. Las falsificaciones suponen reclamaciones, dañan la imagen y obligan a producir de nuevo.", + "card3_title": "Rendimiento inestable", + "card3_text": "Controladores lentos, firmware inestable y velocidades variables son típicos en los falsos y aumentan el riesgo de errores, sobre todo con archivos grandes." + }, + "features": { + "kicker": "Funciones Free & Pro", + "title": "Empieza con el test gratuito y cambia a Pro cuando lo necesites.", + "intro": "USBCheck crece con tus necesidades: los usuarios privados suelen necesitar una respuesta rápida; los profesionales quieren profundizar, validar la capacidad y archivar informes. Para eso está el modo Pro.", + "free_title": "Free Quick Check", + "free_badge": "Recomendado para la mayoría", + "free_text": "Perfecto para quien desea comprobar rápidamente si una memoria funciona de forma razonablemente rápida y estable, sin instalar nada.", + "free_li1": "• Test rápido en el navegador directamente sobre tu unidad", + "free_li2": "• Velocidades de lectura/escritura con datos reales", + "free_li3": "• Verificación de integridad basada en hash sobre una muestra", + "free_li4": "• Selección de distintos niveles de prueba (p. ej. 200 MB, 2 GB)", + "free_li5": "• No requiere registro", + "free_cta": "Iniciar test rápido gratuito", + "pro_title": "Modo Pro", + "pro_badge": "Para usuarios avanzados y equipos", + "pro_text": "Para departamentos de TI, técnicos, reacondicionadores o empresas que prueban grandes volúmenes y necesitan control total.", + "pro_li1": "• Escaneo profundo de toda la capacidad (similar a F3/badblocks)", + "pro_li2": "• Detecta falsos de capacidad y zonas defectuosas", + "pro_li3": "• Informes detallados y guardables (JSON, PDF)", + "pro_li4": "• Acceso API opcional para procesos automatizados", + "pro_li5": "• Soporte multi-dispositivo y multiusuario mediante el área de login", + "pro_note": "El modo Pro requiere una pequeña herramienta auxiliar en tu sistema. Funciona localmente y puede enlazarse con tu cuenta USBCheck cuando lo necesites." + }, + "security": { + "kicker": "Seguridad & privacidad", + "title": "Diseño privacy-first: tus datos de prueba son tuyos.", + "intro": "USBCheck se creó para que tus datos permanezcan protegidos. El test rápido del navegador solo usa archivos de prueba; tus documentos, fotos o copias no se leen ni se suben. En el modo Pro decides si, y cuáles, informes se sincronizan con tu cuenta.", + "card1_title": "Tests solo locales", + "card1_text": "Todas las pruebas de escritura y lectura se realizan localmente en tu USB. El navegador solo accede a los archivos de prueba, no a tu contenido personal.", + "card2_title": "Informes transparentes", + "card2_text": "Si inicias sesión puedes guardar informes en tu cuenta, exportarlos o eliminarlos otra vez. Tú decides qué permanece en el sistema.", + "card3_title": "Cuida tu hardware", + "card3_text": "El test rápido utiliza volúmenes moderados para evitar desgaste innecesario. El modo Pro avisa claramente cuando se ejecuta un escaneo completo con mucha escritura." + }, + "faq": { + "kicker": "FAQ", + "title": "Preguntas frecuentes sobre USBCheck", + "intro": "Aquí encontrarás respuestas a las preguntas más comunes. Amplía el apartado cuando surjan nuevos casos o recibas feedback.", + "q1": "¿El test rápido se ejecuta completamente en el navegador?", + "a1": "Sí. El test funciona íntegramente en el navegador y usa APIs modernas para escribir y leer archivos de prueba en tu unidad. Nada se sube sin tu consentimiento.", + "q2": "¿Necesito una cuenta para usar el test rápido?", + "a2": "No. El test gratuito funciona sin registro. El login solo es necesario si quieres guardar informes, gestionar varias unidades o usar el modo Pro.", + "q3": "¿USBCheck detecta siempre un USB falso?", + "a3": "Ninguna herramienta puede garantizar el 100%. Pero el modo Pro con escaneo completo está pensado para reconocer de forma fiable los patrones típicos: capacidad declarada frente a física, zonas inestables o errores a partir de cierto llenado.", + "q4": "¿Cómo encaja la herramienta en mi flujo de trabajo?", + "a4": "USBCheck está pensado para la automatización. Con el modo Pro y la API prevista puedes integrar las pruebas en procesos existentes, por ejemplo controles de recepción o calidad." + } + } + }, + "fakecheck": { + "meta": { + "title": "FakeCheck – Prueba en el navegador para USB", + "description": "FakeCheck te ayuda a detectar falsificaciones típicas: pruebas de lectura/escritura basadas en navegador y comprobaciones de plausibilidad de la capacidad útil, sin instalación." + }, + "sections": { + "hero": { + "kicker": "FakeCheck – modo navegador", + "title": "¿Mi USB es falso?", + "lead": "FakeCheck te ayuda a detectar falsos típicos: pruebas de lectura/escritura en el navegador y comprobaciones de la capacidad utilizable, sin instalación.", + "cta_start": "Iniciar prueba en el navegador (demo)", + "cta_back_home": "Volver a la vista general", + "hint": "El modo navegador de FakeCheck trabaja con archivos de prueba y patrones de lectura/escritura que creas en una carpeta seleccionada. Tus archivos reales permanecen intactos." + }, + "capabilities": { + "title": "Qué puede hacer la prueba en el navegador", + "point1_title": "Prueba de escritura/lectura con archivos de prueba", + "point1_text": "El navegador crea archivos de prueba en la carpeta elegida, mide la velocidad de escritura/lectura y comprueba si los datos leídos coinciden con los patrones escritos.", + "point2_title": "Chequeo de plausibilidad de capacidad", + "point2_text": "La cantidad de datos escritos y verificados ofrece una idea realista de cuánta capacidad utilizable es realmente estable.", + "point3_title": "Informe JSON para tu documentación", + "point3_text": "Todos los resultados se recogen en un informe JSON estructurado que puedes guardar, subir o reutilizar más adelante." + }, + "app": { + "title": "Interfaz de prueba en el navegador (preview)", + "intro": "Aquí vivirá la app web de FakeCheck: eliges carpeta, configuras la cantidad de test, ves el progreso y el panel de resultados. Por ahora el botón superior solo muestra una salida demo.", + "point1": "Test rápido con una cantidad pequeña de datos.", + "point2": "Benchmark ligero: velocidad de escritura/lectura durante un tiempo limitado.", + "point3": "Write/Verify: escribe archivos de prueba y verifícalos inmediatamente." + }, + "result": { + "title": "Salida demo de la prueba en el navegador", + "hint": "Esta salida es solo una vista previa. Más adelante aquí aparecerá el informe JSON real del test en el navegador." + } + } + }, + "login": { + "meta": { + "title": "Login – {{primary_domain}}", + "description": "Inicia sesión en {{primary_domain}} para guardar tests, usar el modo Pro y gestionar varios dispositivos." + }, + "sections": { + "auth": { + "kicker": "Cuenta & login", + "title": "Inicia sesión en USBCheck", + "intro": "Con una cuenta puedes guardar tests, exportar informes y usar el modo Pro en varios dispositivos. El registro es gratuito; podrás pasar a Pro cuando quieras.", + "tab_login": "Login", + "tab_register": "Registrarse", + "login_title": "Login", + "login_text": "Inicia sesión con tu correo electrónico y contraseña.", + "login_email_label": "Correo electrónico", + "login_password_label": "Contraseña", + "login_submit": "Entrar", + "login_forgot": "¿Olvidaste la contraseña?", + "register_title": "Registro gratuito", + "register_text": "Crea una cuenta gratis para guardar pruebas, exportar informes y desbloquear el modo Pro más adelante.", + "register_name_label": "Nombre", + "register_email_label": "Correo electrónico", + "register_password_label": "Contraseña", + "register_submit": "Crear cuenta", + "register_hint": "Al registrarte aceptas la política de privacidad y el aviso legal de USBCheck." + } + } + }, + "dashboard": { + "meta": { + "title": "Dashboard – {{primary_domain}}", + "description": "Gestiona tus pruebas USB, dispositivos y ajustes del modo Pro en tu panel personal." + }, + "sections": { + "main": { + "kicker": "Panel", + "title": "Bienvenido", + "intro": "Gestiona tus pruebas USB, organiza los dispositivos y pronto activa el modo Pro. Esta zona aún está en construcción, pero ya te da una primera vista.", + "plan_label": "Plan actual", + "card_tests_title": "Últimas pruebas", + "card_tests_text": "Aquí aparecerán tus últimos quick checks y escaneos Pro, con estado, velocidad e información de integridad.", + "card_tests_empty": "Todavía no hay datos. Inicia tu primera prueba desde el navegador o el modo Pro.", + "card_devices_title": "Tus dispositivos USB", + "card_devices_text": "Pronto podrás gestionar aquí las memorias probadas: fabricante, modelo, número de serie y capacidad detectada.", + "card_devices_empty": "Aún no tienes dispositivos guardados. Después de tus primeras pruebas podrás añadirlos aquí.", + "card_next_title": "Próximos pasos", + "card_next_text": "USBCheck sigue evolucionando. Eres de los primeros usuarios; más adelante encontrarás aquí opciones Pro, acceso API e informes detallados.", + "card_next_item1": "• Probar el FakeCheck del navegador y dar feedback", + "card_next_item2": "• Definir funciones del modo Pro (por ejemplo escaneo completo, informes, API)", + "card_next_item3": "• Finalizar cuentas y SSO (my-log.in)", + "card_next_cta": "Ir al FakeCheck del navegador" + } } } } diff --git a/public/assets/i18n/fr.json b/public/assets/i18n/fr.json index 2ec5931..a4a83a8 100644 --- a/public/assets/i18n/fr.json +++ b/public/assets/i18n/fr.json @@ -5,64 +5,51 @@ "flag": "🇫🇷", "enabled": true }, - "header": { "header_slogan": "Tester des clés USB", "btn_login": "Connexion", - "nav_how": "Fonctionnement", "nav_problem": "Pourquoi c’est important", "nav_features": "Fonctionnalités", "nav_security": "Sécurité", "nav_faq": "FAQ" }, - "brand": { "brand_wordmark": "{{primary_domain}}", "brand_subtitle": "Tester les clés USB contre les contrefaçons" }, - "footer": { "footer_imprint": "Mentions légales", "footer_privacy": "Confidentialité", "footer_copy": "© {year} {{primary_domain}}. Tous droits réservés." }, - "fake_ui": { "error_fsapi_not_supported": "Ce navigateur ne prend pas en charge l’API File System Access.", "error_no_directory_selected": "Aucun dossier sélectionné.", "error_no_space_detected": "Impossible de réserver de l’espace libre dans le dossier choisi.", - "log_capacity_probe_start": "Mesure de l’espace disponible dans le dossier choisi...", "log_capacity_probe_result": "Espace utilisable détecté pour les tests : {size} (écriture de test).", - "log_quick_prepare": "Quick Check : préparation... (taille du test : {size})", "log_quick_verify_start": "Quick Check : écriture terminée. Vérification des données...", "log_quick_data_error": "Quick Check : erreur de données à l’octet {byte}.", "error_quick_data_error": "Erreur de données dans le Quick Check à l’octet {byte}.", "log_quick_delete_warn": "Quick Check : impossible de supprimer le fichier de test (non critique).", "log_quick_success": "Quick Check terminé avec succès.", - "log_bench_start": "Benchmark : démarrage – écriture du fichier ({size})...", "log_bench_read_start": "Benchmark : lecture et timing...", "log_bench_delete_warn": "Benchmark : impossible de supprimer le fichier de test (non critique).", "log_bench_success": "Benchmark terminé avec succès.", - "log_wv_start": "Write/Verify : démarrage – {blocks} blocs de {size} (total {total})...", "log_wv_block_start": "Write/Verify : bloc {num}/{blocks} – {file}", "log_wv_data_error": "Write/Verify : erreur de données dans le bloc {num} à l’octet {byte}.", "error_wv_data_error": "Erreur de données dans le bloc {num} à l’octet {byte}.", "log_wv_delete_warn": "Write/Verify : impossible de supprimer le fichier {file} (non critique).", "log_wv_success": "Write/Verify : tous les blocs vérifiés avec succès.", - "log_all_subtest_start": "All-Inclusive : lancement du sous-test « {mode} » ({num}/{total})...", "error_unknown_mode": "Mode inconnu : {mode}", - "log_fsapi_partial": "Votre navigateur ne prend pas totalement en charge l’API File System Access. Certaines fonctions seront désactivées.", - "selected_path_label": "Dossier USB sélectionné (nom : « {name} »).", "selected_path_none": "Aucun dossier sélectionné pour l’instant.", - "status_ready": "Prêt. Sélectionnez d’abord votre clé USB.", "status_mode_none": "Aucun mode sélectionné", "status_dir_selected": "Dossier USB sélectionné. Choisissez un mode de test.", @@ -72,13 +59,11 @@ "status_aborted": "Test interrompu.", "status_error": "Erreur : {msg}", "status_error_unknown": "Erreur inconnue durant le test.", - "overall_initial": "Aucun test n’a encore été effectué.", "overall_running": "Test en cours...", "overall_done": "Test navigateur terminé avec succès.", "overall_aborted": "Test interrompu.", "overall_error": "Échec du test navigateur.", - "log_dir_selected": "Dossier sélectionné : {name}", "log_dir_reset": "Sélection du dossier réinitialisée.", "log_pick_abort": "Sélection du dossier annulée.", @@ -90,20 +75,16 @@ "log_test_error": "Erreur pendant le test : {msg}", "log_test_error_unknown": "Erreur inconnue pendant le test.", "log_loaded": "Test navigateur USB (fakecheck) chargé. En attente du dossier et du mode.", - "mode_quick": "Quick-Check", "mode_benchmark": "Benchmark", "mode_writeverify": "Write & Verify", "mode_all": "All-Inclusive (tous les tests)", - "log_backend_save_error_status": "Backend : impossible d’enregistrer le résultat ({status}).", "log_backend_save_ok": "Backend : résultat enregistré{suffix}.", "log_backend_save_error": "Erreur lors de l’enregistrement côté serveur : {msg}" }, - "serial": { "rating_label": "Évaluation", - "rating": { "ok": { "label": "Plausible", @@ -126,17 +107,14 @@ "desc": "Impossible d’obtenir un verdict clair." } }, - "heading_input": "Données saisies", "heading_analysis": "Analyse du numéro de série", "heading_consistency": "Cohérence fabricant", - "input": { "manufacturer": "Fabricant (déclaré) :", "vidpid": "VID/PID :", "vendor_detected": "Fabricant détecté via la VID :" }, - "analysis": { "serial": "Numéro de série :", "length": "Longueur :", @@ -144,30 +122,223 @@ "score": "Score :", "issues": "Observations :" }, - "chars": "caractères", "none": "non renseigné", - "issues_none": "Aucune observation particulière.", - "vendor_detected": "{vendor} (VID {vid})", "vendor_unknown": "Fabricant inconnu pour la VID {vid}", "vendor_none": "Aucune VID fournie", - "disclaimer": "Cette évaluation est heuristique et ne garantit pas l’authenticité.", - "error": { "no_serial": "Veuillez saisir un numéro de série.", "api": "Erreur lors de la vérification : {msg}", "unknown": "Réponse inattendue du serveur." } }, - "pages": { "landing": { "meta": { - "title": "{{primary_domain}} – Tester vos clés USB contre les faux", - "description": "USBCheck combine un test rapide dans le navigateur et un mode Pro professionnel pour détecter les clés contrefaites avant la perte de données." + "title": "{{primary_domain}} – Testez vos clés USB contre les contrefaçons", + "description": "USBCheck combine un contrôle rapide dans le navigateur et un mode Pro professionnel pour identifier les clés factices, les capacités manquantes et les contrôleurs lents avant que vos fichiers ne disparaissent." + }, + "sections": { + "hero": { + "kicker": "Détectez les USB factices avant de perdre des données", + "title": "Ma clé USB est-elle un faux ?", + "lead": "USBCheck combine un contrôle rapide dans le navigateur et un mode Pro professionnel pour identifier les clés factices, les capacités manquantes et les contrôleurs lents avant que vos fichiers ne disparaissent.", + "cta_quick": "Lancer le test rapide gratuit", + "cta_learn": "En savoir plus sur Free & Pro" + }, + "trust": { + "t1_title": "Aucune installation pour le test rapide", + "t1_text": "Test basé sur le navigateur directement sur votre clé.", + "t2_title": "Vrais tests d’écriture et de lecture", + "t2_text": "Tests réalisés avec des données réelles, pas de benchmarks synthétiques.", + "t3_title": "Confidentialité d’abord", + "t3_text": "Vos données de test restent locales – vous n’envoyez un rapport que si vous le souhaitez." + }, + "quick": { + "label": "Aperçu du test rapide", + "title": "Testez une clé USB en moins de 2 minutes", + "badge_free": "Gratuit", + "intro": "Le test rapide écrit un volume défini de données sur votre clé et mesure :", + "li1": "Vitesse d’écriture et de lecture", + "li2": "Intégrité des données (comparaison de hachages)", + "li3": "Arrêts ou erreurs suspects", + "metric1_label": "Performance d’écriture", + "metric1_value": "~ 75–120 Mo/s*", + "metric2_label": "Contrôle d’intégrité", + "metric2_value": "512 Mo de données de test", + "footnote": "*Valeurs d’exemple – vos résultats dépendent de la clé, du port et du système.", + "cta": "Accéder au test rapide gratuit", + "visual_title": "Affichage du test rapide", + "visual_text": "Voici l’aperçu du Quick Check : le vert indique des données stables, l’orange avertit lorsque la vitesse chute.", + "visual_window": "Fenêtre de résultat" + }, + "how": { + "kicker": "Comment fonctionne USBCheck", + "title": "Test rapide dans le navigateur, mode Pro avec analyse approfondie.", + "intro": "USBCheck a été conçu pour réunir deux mondes : un test rapide simple pour tous et un mode Pro approfondi pour les power users, techniciens et administrateurs. Le test rapide s’exécute directement dans le navigateur sans installation. Le mode Pro utilise un petit outil capable d’effectuer des tests de type F3/badblocks pour démasquer les faux en capacité.", + "step1_title": "Démarrer le test navigateur", + "step1_text": "Ouvrez le test rapide sur {{primary_url}}/fakecheck/, sélectionnez votre clé USB ou un dossier et définissez la quantité de données à tester.", + "step2_title": "Test d’écriture, de lecture et d’intégrité", + "step2_text": "Le navigateur crée des fichiers de test, mesure les vitesses d’écriture/lecture et compare les hachages pour détecter les erreurs – tout reste local, sans téléverser vos contenus.", + "step3_title": "Option : mode Pro pour un scan complet", + "step3_text": "Si vous avez besoin de plus de détails, installez l’outil auxiliaire optionnel. Il peut vérifier toute la capacité, repérer les faux et générer des rapports détaillés – idéal pour les reconditionneurs, équipes IT ou laboratoires.", + "side_title": "Free vs. Pro en un coup d’œil", + "side_free": "Free Quick Check : test de vitesse et d’intégrité dans le navigateur – parfait pour des évaluations rapides.", + "side_pro": "Mode Pro : scan en profondeur, validation de capacité, rapports étendus et intégration API pour les entreprises.", + "side_account": "Compte & login : après connexion vous pouvez enregistrer des tests, exporter des rapports et gérer plusieurs appareils." + }, + "problem": { + "kicker": "Pourquoi les faux USB sont dangereux", + "title": "Les clés USB factices coûtent de l’argent – et parfois vos données.", + "p1": "De nombreuses clés bon marché annoncent des capacités irréalistes. Leur contrôleur est manipulé : la clé affiche 256 Go alors que seuls 32 Go sont présents. Les fichiers semblent copiés correctement, mais sont écrasés ou corrompus plus tard.", + "p2": "USBCheck vous aide à repérer ces faux avant de les utiliser, que ce soit pour un usage privé ou pour contrôler de grands lots en entreprise.", + "card1_title": "Perte de fichiers critiques", + "card1_text": "Photos, projets, sauvegardes… tout est en danger si la clé stocke moins que promis. Les secteurs défectueux restent souvent invisibles jusqu’à ce qu’il soit trop tard.", + "card2_title": "Coûts des lots défectueux", + "card2_text": "Entreprises, revendeurs et agences distribuent des clés en quantité. Les contrefaçons engendrent réclamations, atteintes à l’image et relancements de production.", + "card3_title": "Performances instables", + "card3_text": "Contrôleurs lents, firmware instable et vitesses fluctuantes sont typiques des faux, ce qui augmente les risques d’erreur – surtout avec de gros fichiers." + }, + "features": { + "kicker": "Fonctionnalités Free & Pro", + "title": "Commencez avec le test gratuit et passez en Pro quand vous en avez besoin.", + "intro": "USBCheck évolue avec vos besoins : les particuliers veulent souvent une réponse rapide, les professionnels souhaitent approfondir, valider la capacité et archiver des rapports – c’est l’objectif du mode Pro.", + "free_title": "Free Quick Check", + "free_badge": "Recommandé pour la plupart des utilisateurs", + "free_text": "Idéal pour vérifier rapidement si une clé fonctionne de manière suffisamment rapide et stable, sans rien installer.", + "free_li1": "• Test rapide basé sur le navigateur directement sur votre clé", + "free_li2": "• Mesure des vitesses d’écriture/lecture avec de vraies données", + "free_li3": "• Contrôle d’intégrité basé sur des hachages d’un échantillon", + "free_li4": "• Choix de différents niveaux de test (ex. 200 Mo, 2 Go)", + "free_li5": "• Aucun enregistrement requis", + "free_cta": "Lancer le test rapide gratuit", + "pro_title": "Mode Pro", + "pro_badge": "Pour power users & équipes", + "pro_text": "Pour les services IT, techniciens, reconditionneurs ou entreprises qui testent de grands volumes et ont besoin d’un contrôle total.", + "pro_li1": "• Scan complet de la capacité (similaire à F3/badblocks)", + "pro_li2": "• Détection des faux en capacité et des zones défectueuses", + "pro_li3": "• Rapports détaillés, exportables (JSON, PDF)", + "pro_li4": "• Accès API optionnel pour des workflows automatisés", + "pro_li5": "• Support multi-appareils et multiutilisateurs via l’espace login", + "pro_note": "Le mode Pro nécessite un petit outil sur votre système. Il fonctionne localement et peut se connecter à votre compte USBCheck si besoin." + }, + "security": { + "kicker": "Sécurité & confidentialité", + "title": "Privacy-by-design : vos données de test vous appartiennent.", + "intro": "USBCheck est conçu pour protéger vos données. Le test rapide du navigateur n’utilise que des fichiers de test. Vos documents, photos ou sauvegardes ne sont ni lus ni envoyés. En mode Pro, vous décidez si – et quels – rapports sont synchronisés avec votre compte.", + "card1_title": "Tests 100 % locaux", + "card1_text": "Tous les tests d’écriture/lecture se font localement sur votre clé. Le navigateur n’accède qu’aux fichiers de test, pas à vos contenus privés.", + "card2_title": "Rapports transparents", + "card2_text": "Après connexion, vous pouvez enregistrer, exporter ou supprimer les rapports. C’est vous qui décidez ce qui reste dans le système.", + "card3_title": "Respecte votre matériel", + "card3_text": "Le test rapide utilise un volume modéré pour éviter l’usure inutile. Le mode Pro avertit clairement lorsque vous lancez un scan complet intensif." + }, + "faq": { + "kicker": "FAQ", + "title": "Questions fréquentes sur USBCheck", + "intro": "Trouvez ici les réponses aux questions les plus fréquentes. Ajoutez-en au besoin lorsque de nouveaux cas d’usage apparaissent ou que vous recevez des retours.", + "q1": "Le test rapide se déroule-t-il entièrement dans le navigateur ?", + "a1": "Oui. Le test fonctionne exclusivement dans le navigateur et utilise des API modernes pour écrire et lire les fichiers de test sur votre clé. Rien n’est téléversé sans votre accord.", + "q2": "Dois-je avoir un compte pour utiliser le test rapide ?", + "a2": "Non. Le test gratuit fonctionne sans inscription. Vous ne devez vous connecter que si vous souhaitez enregistrer des rapports, gérer plusieurs clés ou utiliser le mode Pro.", + "q3": "USBCheck peut-il détecter tous les faux ?", + "a3": "Aucun outil ne peut garantir 100 %. Mais le mode Pro avec scan complet est conçu pour reconnaître de manière fiable les schémas classiques : capacité déclarée vs réelle, zones instables ou erreurs après un certain remplissage.", + "q4": "Comment intégrer l’outil à mon workflow ?", + "a4": "USBCheck est pensé pour l’automatisation. Avec le mode Pro et l’API prévue, vous pouvez intégrer les tests à vos processus existants, par exemple les contrôles de réception ou la qualité." + } + } + }, + "fakecheck": { + "meta": { + "title": "FakeCheck – Test navigateur pour clés USB", + "description": "FakeCheck vous aide à repérer les faux typiques : tests d’écriture/lecture dans le navigateur et contrôles de plausibilité de la capacité utilisable – sans installation." + }, + "sections": { + "hero": { + "kicker": "FakeCheck – mode navigateur", + "title": "Ma clé USB est-elle factice ?", + "lead": "FakeCheck vous aide à détecter les faux typiques : tests d’écriture/lecture dans le navigateur et contrôles de capacité, sans installation.", + "cta_start": "Lancer le test navigateur (démo)", + "cta_back_home": "Revenir à l’aperçu", + "hint": "Le mode navigateur FakeCheck fonctionne avec des fichiers de test et des motifs de lecture/écriture créés dans un dossier choisi. Vos vrais fichiers restent intacts." + }, + "capabilities": { + "title": "Ce que peut faire le test navigateur", + "point1_title": "Test écriture/lecture avec fichiers de test", + "point1_text": "Le navigateur crée des fichiers de test dans le dossier choisi, mesure les vitesses d’écriture/lecture et vérifie si les données relues correspondent aux motifs écrits.", + "point2_title": "Contrôle de plausibilité de la capacité", + "point2_text": "La quantité de données écrites et vérifiées donne une idée réaliste de la capacité réellement exploitable.", + "point3_title": "Rapport JSON pour votre documentation", + "point3_text": "Tous les résultats sont réunis dans un rapport JSON structuré que vous pouvez sauvegarder, téléverser ou réutiliser plus tard." + }, + "app": { + "title": "Interface du test navigateur (aperçu)", + "intro": "Ici se trouvera l’app web FakeCheck : sélection du dossier, configuration du volume de test, affichage de la progression et des résultats. Pour l’instant, le bouton affiche seulement une sortie de démonstration.", + "point1": "Quick-test avec un petit volume de données.", + "point2": "Benchmark léger : vitesse écriture/lecture sur une durée limitée.", + "point3": "Write/Verify : écrire des fichiers de test puis les vérifier immédiatement." + }, + "result": { + "title": "Sortie démo du test navigateur", + "hint": "Ce résultat est uniquement un aperçu. Plus tard, le véritable rapport JSON issu du test navigateur sera affiché ici." + } + } + }, + "login": { + "meta": { + "title": "Connexion – {{primary_domain}}", + "description": "Connectez-vous sur {{primary_domain}} pour enregistrer vos tests, utiliser le mode Pro et gérer plusieurs appareils." + }, + "sections": { + "auth": { + "kicker": "Compte & connexion", + "title": "Connectez-vous à USBCheck", + "intro": "Avec un compte vous pouvez enregistrer des tests, exporter des rapports et utiliser le mode Pro sur plusieurs appareils. L’inscription est gratuite – vous pourrez passer en Pro plus tard.", + "tab_login": "Connexion", + "tab_register": "Inscription", + "login_title": "Connexion", + "login_text": "Connectez-vous avec votre adresse e-mail et votre mot de passe.", + "login_email_label": "Adresse e-mail", + "login_password_label": "Mot de passe", + "login_submit": "Se connecter", + "login_forgot": "Mot de passe oublié ?", + "register_title": "Inscription gratuite", + "register_text": "Créez un compte gratuit pour enregistrer vos tests, exporter des rapports et débloquer le mode Pro plus tard.", + "register_name_label": "Nom", + "register_email_label": "Adresse e-mail", + "register_password_label": "Mot de passe", + "register_submit": "Créer un compte", + "register_hint": "En vous inscrivant, vous acceptez la politique de confidentialité et les mentions légales d’USBCheck." + } + } + }, + "dashboard": { + "meta": { + "title": "Dashboard – {{primary_domain}}", + "description": "Gérez vos tests USB, vos appareils et les paramètres du mode Pro dans votre tableau de bord personnel." + }, + "sections": { + "main": { + "kicker": "Tableau de bord", + "title": "Bienvenue", + "intro": "Gérez vos tests USB, organisez vos appareils et activez bientôt le mode Pro. Cette zone est encore en construction, mais vous offre déjà un premier aperçu.", + "plan_label": "Offre actuelle", + "card_tests_title": "Derniers tests", + "card_tests_text": "Vos derniers quick checks et scans Pro s’afficheront ici – avec statut, vitesse et intégrité.", + "card_tests_empty": "Aucune donnée pour l’instant. Lancez votre premier test via le navigateur ou le mode Pro", + "card_devices_title": "Vos appareils USB", + "card_devices_text": "Bientôt vous gérerez ici les clés testées : fabricant, modèle, numéro de série et capacité détectée.", + "card_devices_empty": "Aucun appareil enregistré pour le moment. Après vos premiers tests vous pourrez les ajouter ici.", + "card_next_title": "Prochaines étapes", + "card_next_text": "USBCheck continue d’évoluer. Vous faites partie des premiers utilisateurs – plus tard vous trouverez ici les options Pro, l’accès API et des rapports détaillés.", + "card_next_item1": "• Tester le FakeCheck navigateur et donner votre avis", + "card_next_item2": "• Définir les fonctionnalités du mode Pro (scan complet, rapports, API)", + "card_next_item3": "• Finaliser les comptes & le SSO (my-log.in)", + "card_next_cta": "Accéder au FakeCheck navigateur" + } } } } diff --git a/public/assets/i18n/it.json b/public/assets/i18n/it.json index 7023e24..7dfa2ca 100644 --- a/public/assets/i18n/it.json +++ b/public/assets/i18n/it.json @@ -5,64 +5,51 @@ "flag": "🇮🇹", "enabled": true }, - "header": { "header_slogan": "Testare chiavette USB", "btn_login": "Login", - "nav_how": "Come funziona", "nav_problem": "Perché è importante", "nav_features": "Funzioni", "nav_security": "Sicurezza", "nav_faq": "FAQ" }, - "brand": { "brand_wordmark": "{{primary_domain}}", "brand_subtitle": "Controlla le chiavette USB contro i falsi" }, - "footer": { "footer_imprint": "Note legali", "footer_privacy": "Privacy", "footer_copy": "© {year} {{primary_domain}}. Tutti i diritti riservati." }, - "fake_ui": { "error_fsapi_not_supported": "Questo browser non supporta la File System Access API.", "error_no_directory_selected": "Nessuna cartella selezionata.", "error_no_space_detected": "Impossibile riservare spazio libero nella cartella scelta.", - "log_capacity_probe_start": "Verifico lo spazio disponibile nella cartella selezionata...", "log_capacity_probe_result": "Spazio utilizzabile rilevato per i test: {size} (scrittura di prova).", - "log_quick_prepare": "Quick-Check: preparazione... (dimensione test: {size})", "log_quick_verify_start": "Quick-Check: scrittura completata. Verifico i dati...", "log_quick_data_error": "Quick-Check: errore dati al byte {byte}.", "error_quick_data_error": "Errore dati nel Quick-Check al byte {byte}.", "log_quick_delete_warn": "Quick-Check: impossibile eliminare il file di test (non critico).", "log_quick_success": "Quick-Check: completato con successo.", - "log_bench_start": "Benchmark: inizio – scrivo il file di test ({size})...", "log_bench_read_start": "Benchmark: lettura e timing...", "log_bench_delete_warn": "Benchmark: impossibile eliminare il file di test (non critico).", "log_bench_success": "Benchmark: completato con successo.", - "log_wv_start": "Write/Verify: avvio – {blocks} blocchi da {size} (totale {total})...", "log_wv_block_start": "Write/Verify: blocco {num}/{blocks} – {file}", "log_wv_data_error": "Write/Verify: errore dati nel blocco {num} al byte {byte}.", "error_wv_data_error": "Errore dati nel blocco {num} al byte {byte}.", "log_wv_delete_warn": "Write/Verify: impossibile eliminare il file {file} (non critico).", "log_wv_success": "Write/Verify: tutti i blocchi verificati correttamente.", - "log_all_subtest_start": "All-Inclusive: avvio del sotto-test \"{mode}\" ({num}/{total})...", "error_unknown_mode": "Modalità sconosciuta: {mode}", - "log_fsapi_partial": "Il tuo browser non supporta completamente la File System Access API. Alcune funzioni saranno disattivate.", - "selected_path_label": "Cartella USB selezionata (nome: \"{name}\").", "selected_path_none": "Nessuna cartella selezionata.", - "status_ready": "Pronto. Seleziona prima la chiavetta USB.", "status_mode_none": "Nessuna modalità selezionata", "status_dir_selected": "Cartella USB selezionata. Scegli una modalità.", @@ -72,13 +59,11 @@ "status_aborted": "Test annullato.", "status_error": "Errore: {msg}", "status_error_unknown": "Errore sconosciuto durante il test.", - "overall_initial": "Nessuna prova eseguita finora.", "overall_running": "Test in corso...", "overall_done": "Test del browser completato con successo.", "overall_aborted": "Test annullato.", "overall_error": "Errore nel test del browser.", - "log_dir_selected": "Cartella selezionata: {name}", "log_dir_reset": "Selezione cartella reimpostata.", "log_pick_abort": "Selezione della cartella annullata.", @@ -90,20 +75,16 @@ "log_test_error": "Errore durante il test: {msg}", "log_test_error_unknown": "Errore sconosciuto durante il test.", "log_loaded": "Test del browser USB (fakecheck) caricato. In attesa di cartella e modalità.", - "mode_quick": "Quick-Check", "mode_benchmark": "Benchmark", "mode_writeverify": "Write & Verify", "mode_all": "All-Inclusive (tutti i test)", - "log_backend_save_error_status": "Backend: impossibile salvare il risultato ({status}).", "log_backend_save_ok": "Backend: risultato salvato{suffix}.", "log_backend_save_error": "Errore durante il salvataggio nel backend: {msg}" }, - "serial": { "rating_label": "Valutazione", - "rating": { "ok": { "label": "Plausibile", @@ -126,17 +107,14 @@ "desc": "Non è stato possibile determinare un verdetto." } }, - "heading_input": "Dati inseriti", "heading_analysis": "Analisi numero di serie", "heading_consistency": "Coerenza del produttore", - "input": { "manufacturer": "Produttore (dato utente):", "vidpid": "VID/PID:", "vendor_detected": "Produttore ricavato dalla VID:" }, - "analysis": { "serial": "Numero di serie:", "length": "Lunghezza:", @@ -144,30 +122,223 @@ "score": "Punteggio:", "issues": "Osservazioni:" }, - "chars": "caratteri", "none": "non indicato", - "issues_none": "Nessuna osservazione particolare.", - "vendor_detected": "{vendor} (VID {vid})", "vendor_unknown": "Produttore sconosciuto per VID {vid}", "vendor_none": "Nessuna VID fornita", - "disclaimer": "Questa valutazione è euristica e non garantisce l'autenticità.", - "error": { "no_serial": "Inserisci un numero di serie.", "api": "Errore durante la verifica: {msg}", "unknown": "Risposta inattesa dal server." } }, - "pages": { "landing": { "meta": { - "title": "{{primary_domain}} – Testa le tue USB contro i falsi", - "description": "USBCheck combina un test rapido nel browser con un Pro Mode professionale. Scopri i falsi prima di perdere i tuoi dati." + "title": "{{primary_domain}} – Verifica le chiavette USB contro i falsi", + "description": "USBCheck combina un controllo rapido nel browser con un Pro Mode professionale per individuare chiavette false, capacità mancanti e controller lenti prima che i tuoi file vadano persi." + }, + "sections": { + "hero": { + "kicker": "Scopri le USB false prima di perdere i dati", + "title": "La mia chiavetta USB è un falso?", + "lead": "USBCheck combina un controllo rapido nel browser con un Pro Mode professionale per individuare chiavette false, capacità mancanti e controller lenti prima che i tuoi file vadano persi.", + "cta_quick": "Avvia il test rapido gratuito", + "cta_learn": "Scopri di più su Free & Pro" + }, + "trust": { + "t1_title": "Nessuna installazione per il test rapido", + "t1_text": "Test basato sul browser direttamente sulla tua chiavetta.", + "t2_title": "Test reali di scrittura e lettura", + "t2_text": "Prove con dati reali, niente benchmark sintetici.", + "t3_title": "Privacy al primo posto", + "t3_text": "I dati di test restano in locale: carichi un report solo se lo desideri." + }, + "quick": { + "label": "Anteprima del test rapido", + "title": "Metti alla prova una USB in meno di 2 minuti", + "badge_free": "Gratis", + "intro": "Il test rapido scrive un set definito di dati sulla chiavetta e misura:", + "li1": "Velocità di scrittura e lettura", + "li2": "Integrità dei dati (confronto hash)", + "li3": "Interruzioni o errori sospetti", + "metric1_label": "Prestazioni di scrittura", + "metric1_value": "~ 75–120 MB/s*", + "metric2_label": "Verifica di integrità", + "metric2_value": "512 MB di dati di test", + "footnote": "*Valori di esempio: i risultati dipendono da chiavetta, porta e sistema.", + "cta": "Vai al test rapido gratuito", + "visual_title": "Schermata del Quick Check", + "visual_text": "Così appare l’anteprima del Quick Check: verde segnala dati stabili, arancione avvisa se la velocità cala.", + "visual_window": "Finestra dei risultati" + }, + "how": { + "kicker": "Come funziona USBCheck", + "title": "Test rapido nel browser, Pro Mode con analisi approfondita.", + "intro": "USBCheck è stato pensato per unire due mondi: un test rapido semplice per tutti e un Pro Mode approfondito per power user, tecnici e amministratori. Il test rapido gira direttamente nel browser senza installazione. Il Pro Mode usa un piccolo tool in grado di eseguire prove tipo F3/badblocks per stanare i falsi di capacità.", + "step1_title": "Avvia il test nel browser", + "step1_text": "Apri il test rapido su {{primary_url}}/fakecheck/, seleziona la tua chiavetta USB o una cartella e scegli la quantità di dati da verificare.", + "step2_title": "Scrittura, lettura e controllo d’integrità", + "step2_text": "Il browser crea file di test, misura le velocità di scrittura/lettura e confronta gli hash per trovare errori, tutto in locale senza caricare i tuoi contenuti.", + "step3_title": "Opzionale: Pro Mode per la scansione completa", + "step3_text": "Se ti servono più dettagli installa il tool opzionale. Può analizzare l’intera capacità, individuare falsi e generare report dettagliati – ideale per refurbisher, team IT o laboratori.", + "side_title": "Free vs. Pro in sintesi", + "side_free": "Free Quick Check: test di velocità e integrità nel browser, perfetto per valutazioni rapide.", + "side_pro": "Pro Mode: scansione profonda, validazione della capacità, report estesi e integrazione API per le aziende.", + "side_account": "Account & login: dopo l’accesso puoi salvare i test, esportare i report e gestire più dispositivi." + }, + "problem": { + "kicker": "Perché le USB false sono rischiose", + "title": "Le chiavette contraffatte costano denaro e, nel peggiore dei casi, i tuoi dati.", + "p1": "Molte chiavette economiche promettono capacità irrealistiche. Il controller è manipolato: dichiara 256 GB anche se fisicamente ce ne sono solo 32. I file sembrano copiarsi, ma più tardi vengono sovrascritti o corrotti.", + "p2": "USBCheck ti aiuta a riconoscere questi falsi prima di usarli, sia per uso privato che per controllare lotti aziendali.", + "card1_title": "Perdita di file importanti", + "card1_text": "Foto, progetti, backup: tutto è a rischio se la chiavetta memorizza meno del promesso. I settori difettosi spesso passano inosservati finché è troppo tardi.", + "card2_title": "Costi dovuti a lotti difettosi", + "card2_text": "Aziende, rivenditori e agenzie distribuiscono chiavette in grandi volumi. I falsi generano reclami, rovinano l’immagine e richiedono nuova produzione.", + "card3_title": "Prestazioni instabili", + "card3_text": "Controller lenti, firmware instabile e velocità ballerine sono tipici dei falsi e aumentano il rischio di errori, soprattutto con file grandi." + }, + "features": { + "kicker": "Funzioni Free & Pro", + "title": "Inizia con il test gratuito e passa a Pro quando ti serve.", + "intro": "USBCheck cresce con le tue esigenze: chi usa l’USB in modo privato vuole una risposta rapida, i professionisti desiderano approfondire, verificare la capacità e archiviare report. È il motivo per cui esiste il Pro Mode.", + "free_title": "Free Quick Check", + "free_badge": "Consigliato alla maggior parte degli utenti", + "free_text": "Perfetto per chi vuole verificare in fretta se una chiavetta è abbastanza veloce e stabile senza installare nulla.", + "free_li1": "• Test rapido basato sul browser direttamente sulla tua USB", + "free_li2": "• Velocità di lettura/scrittura con dati reali", + "free_li3": "• Controllo di integrità basato su hash di un campione", + "free_li4": "• Scelta di diversi livelli di test (es. 200 MB, 2 GB)", + "free_li5": "• Nessuna registrazione richiesta", + "free_cta": "Avvia il test rapido gratuito", + "pro_title": "Pro Mode", + "pro_badge": "Per power user & team", + "pro_text": "Per reparti IT, tecnici, refurbisher o aziende che testano grandi volumi e vogliono controllo totale.", + "pro_li1": "• Scansione profonda dell’intera capacità (simile a F3/badblocks)", + "pro_li2": "• Rileva falsi di capacità e aree difettose", + "pro_li3": "• Report dettagliati e salvabili (JSON, PDF)", + "pro_li4": "• Accesso API opzionale per processi automatizzati", + "pro_li5": "• Supporto multi-device e multiutente tramite l’area login", + "pro_note": "Il Pro Mode richiede un piccolo tool sul tuo sistema. Lavora in locale e può collegarsi al tuo account USBCheck quando serve." + }, + "security": { + "kicker": "Sicurezza & privacy", + "title": "Privacy-first: i tuoi dati di test restano tuoi.", + "intro": "USBCheck è stato progettato per proteggere i tuoi dati. Il test rapido nel browser utilizza solo file di test; i tuoi documenti, foto o backup non vengono letti né caricati. Nel Pro Mode decidi tu se – e quali – report sincronizzare con l’account.", + "card1_title": "Test solo locali", + "card1_text": "Tutti i test di scrittura/lettura avvengono localmente sulla chiavetta. Il browser tocca solo i file di prova, non i tuoi contenuti personali.", + "card2_title": "Report trasparenti", + "card2_text": "Dopo aver effettuato il login puoi salvare i report nell’account, esportarli o cancellarli. Decidi tu cosa resta nel sistema.", + "card3_title": "Delicato sull’hardware", + "card3_text": "Il test rapido usa volumi moderati per evitare usura inutile. Il Pro Mode avvisa chiaramente quando parte una scansione completa e intensa." + }, + "faq": { + "kicker": "FAQ", + "title": "Domande frequenti su USBCheck", + "intro": "Qui trovi le risposte alle domande più comuni. Amplia la sezione ogni volta che emergono nuovi casi d’uso o feedback degli utenti.", + "q1": "Il test rapido avviene interamente nel browser?", + "a1": "Sì. Il test gira completamente nel browser e usa API moderne per scrivere e leggere file di prova sulla tua chiavetta. Niente viene caricato senza il tuo consenso.", + "q2": "Serve un account per usare il test rapido?", + "a2": "No. Il test gratuito funziona senza registrazione. Devi effettuare il login solo se vuoi salvare report, gestire più dispositivi o usare il Pro Mode.", + "q3": "USBCheck può individuare sempre un falso?", + "a3": "Nessuno strumento può garantire il 100%. Il Pro Mode con scansione completa però è progettato per riconoscere con grande affidabilità i pattern tipici: capacità dichiarata contro reale, zone instabili, errori oltre una certa riempitura.", + "q4": "Come si integra lo strumento nel mio workflow?", + "a4": "USBCheck è pensato per l’automazione. Con il Pro Mode e la futura API puoi integrare i test nei tuoi processi esistenti, ad esempio controlli di magazzino o qualità." + } + } + }, + "fakecheck": { + "meta": { + "title": "FakeCheck – Test nel browser per USB", + "description": "FakeCheck ti aiuta a scoprire i falsi tipici: test di scrittura/lettura nel browser e controlli di plausibilità della capacità utilizzabile, senza installazione." + }, + "sections": { + "hero": { + "kicker": "FakeCheck – modalità browser", + "title": "La mia USB è falsa?", + "lead": "FakeCheck ti aiuta a scoprire i falsi più comuni: prove di scrittura/lettura nel browser e controlli di capacità senza installazione.", + "cta_start": "Avvia test browser (demo)", + "cta_back_home": "Torna alla panoramica", + "hint": "Il FakeCheck nel browser lavora con file di prova e pattern di lettura/scrittura che crei nella cartella selezionata. I tuoi file reali restano intatti." + }, + "capabilities": { + "title": "Cosa può fare il test nel browser", + "point1_title": "Test di scrittura/lettura con file di prova", + "point1_text": "Il browser crea file di prova nella cartella scelta, misura le velocità e controlla che i dati letti coincidano con i pattern scritti.", + "point2_title": "Controllo di plausibilità della capacità", + "point2_text": "La quantità di dati scritti e verificati offre un’idea realistica della capacità effettivamente stabile.", + "point3_title": "Report JSON per la documentazione", + "point3_text": "Tutti i risultati confluiscono in un report JSON strutturato che puoi salvare, caricare o riutilizzare in seguito." + }, + "app": { + "title": "Interfaccia del test browser (preview)", + "intro": "Qui nascerà la web app FakeCheck: scegli la cartella, configuri il volume di test, vedi l’avanzamento e il pannello dei risultati. Per ora il pulsante mostra solo un output demo.", + "point1": "Quick test con una piccola quantità di dati.", + "point2": "Benchmark leggero: velocità di scrittura/lettura per un tempo limitato.", + "point3": "Write/Verify: scrivi i file di prova e verificali subito." + }, + "result": { + "title": "Output demo del test nel browser", + "hint": "Questa uscita è solo un’anteprima. Più avanti qui apparirà il vero report JSON generato dal test." + } + } + }, + "login": { + "meta": { + "title": "Login – {{primary_domain}}", + "description": "Accedi a {{primary_domain}} per salvare i test, usare il Pro Mode e gestire più dispositivi." + }, + "sections": { + "auth": { + "kicker": "Account & login", + "title": "Accedi a USBCheck", + "intro": "Con un account puoi salvare i test, esportare i report e usare il Pro Mode su più dispositivi. La registrazione è gratuita e potrai passare a Pro quando vuoi.", + "tab_login": "Login", + "tab_register": "Registrati", + "login_title": "Login", + "login_text": "Accedi con indirizzo e-mail e password.", + "login_email_label": "E-mail", + "login_password_label": "Password", + "login_submit": "Accedi", + "login_forgot": "Password dimenticata?", + "register_title": "Registrati gratis", + "register_text": "Crea un account gratuito per salvare i test, esportare i report e sbloccare il Pro Mode in seguito.", + "register_name_label": "Nome", + "register_email_label": "E-mail", + "register_password_label": "Password", + "register_submit": "Crea account", + "register_hint": "Con la registrazione accetti l’informativa sulla privacy e le note legali di USBCheck." + } + } + }, + "dashboard": { + "meta": { + "title": "Dashboard – {{primary_domain}}", + "description": "Gestisci i tuoi test USB, i dispositivi e le impostazioni del Pro Mode dal tuo pannello personale." + }, + "sections": { + "main": { + "kicker": "Dashboard", + "title": "Benvenuto", + "intro": "Gestisci i test USB, tieni ordinati i dispositivi e presto abilita il Pro Mode. L’area è ancora in costruzione ma offre già una prima anteprima.", + "plan_label": "Piano attuale", + "card_tests_title": "Ultimi test", + "card_tests_text": "Qui appariranno i tuoi ultimi quick check e scan Pro con stato, velocità e integrità.", + "card_tests_empty": "Non ci sono ancora dati. Avvia il primo test dal browser o dal Pro Mode.", + "card_devices_title": "I tuoi dispositivi USB", + "card_devices_text": "Presto potrai gestire qui le chiavette testate: produttore, modello, numero di serie e capacità rilevata.", + "card_devices_empty": "Ancora nessun dispositivo salvato. Dopo i primi test potrai aggiungerli qui.", + "card_next_title": "Prossimi passi", + "card_next_text": "USBCheck è ancora in evoluzione. Sei tra i primi utenti: più avanti troverai qui opzioni Pro, accesso API e report dettagliati.", + "card_next_item1": "• Provare il FakeCheck del browser e inviare feedback", + "card_next_item2": "• Definire le funzioni del Pro Mode (scan completo, report, API)", + "card_next_item3": "• Finalizzare account e SSO (my-log.in)", + "card_next_cta": "Vai al FakeCheck browser" + } } } } diff --git a/public/assets/i18n/us.json b/public/assets/i18n/us.json index 1c80ffd..2d07f94 100644 --- a/public/assets/i18n/us.json +++ b/public/assets/i18n/us.json @@ -5,64 +5,51 @@ "flag": "🇺🇸", "enabled": true }, - "header": { "header_slogan": "Test USB drives", "btn_login": "Login", - "nav_how": "How it works", "nav_problem": "Why it matters", "nav_features": "Features", "nav_security": "Security", "nav_faq": "FAQ" }, - "brand": { "brand_wordmark": "{{primary_domain}}", "brand_subtitle": "Check USB drives for fakes" }, - "footer": { "footer_imprint": "Legal", "footer_privacy": "Privacy", "footer_copy": "© {year} {{primary_domain}}. All rights reserved." }, - "fake_ui": { "error_fsapi_not_supported": "This browser doesn’t support the File System Access API.", "error_no_directory_selected": "No directory selected.", "error_no_space_detected": "Couldn’t reserve free space in the selected directory.", - "log_capacity_probe_start": "Measuring available space in the selected directory...", "log_capacity_probe_result": "Writable space detected for tests: {size} (write probe).", - "log_quick_prepare": "Quick check: preparing… (test size: {size})", "log_quick_verify_start": "Quick check: write completed. Verifying data...", "log_quick_data_error": "Quick check: data error at byte {byte}.", "error_quick_data_error": "Data error in the quick check at byte {byte}.", "log_quick_delete_warn": "Quick check: couldn’t delete test file (not critical).", "log_quick_success": "Quick check finished successfully.", - "log_bench_start": "Benchmark: starting – writing test file ({size})...", "log_bench_read_start": "Benchmark: reading & timing...", "log_bench_delete_warn": "Benchmark: couldn’t delete test file (not critical).", "log_bench_success": "Benchmark completed successfully.", - "log_wv_start": "Write/Verify: starting – {blocks} blocks of {size} (total {total})...", "log_wv_block_start": "Write/Verify: block {num}/{blocks} – {file}", "log_wv_data_error": "Write/Verify: data error in block {num} at byte {byte}.", "error_wv_data_error": "Data error in block {num} at byte {byte}.", "log_wv_delete_warn": "Write/Verify: couldn’t delete block file {file} (not critical).", "log_wv_success": "Write/Verify: all blocks verified successfully.", - "log_all_subtest_start": "All-inclusive: starting subtest \"{mode}\" ({num}/{total})...", "error_unknown_mode": "Unknown mode: {mode}", - "log_fsapi_partial": "Your browser only partially supports the File System Access API. Some features are disabled.", - "selected_path_label": "USB folder selected (name: \"{name}\").", "selected_path_none": "No directory selected yet.", - "status_ready": "Ready. Select your USB drive first.", "status_mode_none": "No mode selected", "status_dir_selected": "USB directory selected. Choose a test mode next.", @@ -72,13 +59,11 @@ "status_aborted": "Test was canceled.", "status_error": "Error: {msg}", "status_error_unknown": "Unknown test error.", - "overall_initial": "No test has been run yet.", "overall_running": "Test running...", "overall_done": "Browser test completed successfully.", "overall_aborted": "Test canceled.", "overall_error": "Browser test failed.", - "log_dir_selected": "Directory selected: {name}", "log_dir_reset": "Directory selection cleared.", "log_pick_abort": "Directory selection canceled.", @@ -90,20 +75,16 @@ "log_test_error": "Test failed: {msg}", "log_test_error_unknown": "Unknown error during the test.", "log_loaded": "USB browser test (fakecheck) loaded. Waiting for directory selection and mode.", - "mode_quick": "Quick check", "mode_benchmark": "Benchmark", "mode_writeverify": "Write & Verify", "mode_all": "All-inclusive (all browser tests)", - "log_backend_save_error_status": "Backend: couldn’t save result ({status}).", "log_backend_save_ok": "Backend: test result saved{suffix}.", "log_backend_save_error": "Error while saving to the backend: {msg}" }, - "serial": { "rating_label": "Rating", - "rating": { "ok": { "label": "Plausible", @@ -126,17 +107,14 @@ "desc": "No clear verdict possible." } }, - "heading_input": "Input data", "heading_analysis": "Serial number analysis", "heading_consistency": "Manufacturer consistency", - "input": { "manufacturer": "Manufacturer (user entry):", "vidpid": "VID/PID:", "vendor_detected": "Vendor from VID:" }, - "analysis": { "serial": "Serial number:", "length": "Length:", @@ -144,30 +122,223 @@ "score": "Score:", "issues": "Findings:" }, - "chars": "characters", "none": "not provided", - "issues_none": "No notable issues.", - "vendor_detected": "{vendor} (VID {vid})", "vendor_unknown": "Unknown manufacturer for VID {vid}", "vendor_none": "No vendor ID provided", - "disclaimer": "This assessment is heuristic and cannot guarantee authenticity.", - "error": { "no_serial": "Please enter a serial number.", "api": "Error during the check: {msg}", "unknown": "Unexpected response from the server." } }, - "pages": { "landing": { "meta": { "title": "{{primary_domain}} – Test USB drives for fakes", - "description": "USBCheck combines a fast browser quick check with a professional Pro mode so you recognize fake drives before they wipe your data." + "description": "USBCheck combines a quick browser check with a professional Pro mode so you can spot fake drives, missing capacity and sluggish controllers before your files disappear." + }, + "sections": { + "hero": { + "kicker": "Spot fake USB drives before you lose data", + "title": "Is my USB drive a fake?", + "lead": "USBCheck combines a quick browser check with a professional Pro mode so you can spot fake drives, missing capacity and sluggish controllers before your files disappear.", + "cta_quick": "Start the free quick check", + "cta_learn": "More about Free & Pro" + }, + "trust": { + "t1_title": "No install for quick check", + "t1_text": "Browser-based test directly on your drive.", + "t2_title": "Real write & read tests", + "t2_text": "Write/read tests with real data – no synthetic benchmarks.", + "t3_title": "Privacy first", + "t3_text": "Your test data stays local – upload reports only if you want." + }, + "quick": { + "label": "Quick check preview", + "title": "Test a USB drive in under 2 minutes", + "badge_free": "Free", + "intro": "The quick check writes a defined data set on your drive and measures:", + "li1": "Write and read speed", + "li2": "Data integrity (hash comparison)", + "li3": "Suspicious aborts or errors", + "metric1_label": "Write performance", + "metric1_value": "~ 75–120 MB/s*", + "metric2_label": "Integrity check", + "metric2_value": "512 MB of test data", + "footnote": "*Example values – your results depend on drive, port & system.", + "cta": "Go to the free quick check", + "visual_title": "Quick check display", + "visual_text": "This is the quick check preview: green marks stable data, orange warns when write speed drops.", + "visual_window": "Result window" + }, + "how": { + "kicker": "How USBCheck works", + "title": "Quick check in the browser, Pro mode with deep analysis.", + "intro": "USBCheck was designed to combine two worlds: an easy quick check for everyone and an in-depth Pro mode for power users, technicians and admins. The quick check runs right in the browser with no install. The Pro mode uses a helper tool that can perform F3/badblocks-style scans to unmask capacity fakes.", + "step1_title": "Start the browser test", + "step1_text": "Open the quick check at {{primary_url}}/fakecheck/, select your USB drive or a folder on it and define how much data should be tested.", + "step2_title": "Write, read and integrity test", + "step2_text": "The browser creates test files, measures write/read speed and compares hashes to detect data errors – everything locally without uploading your content.", + "step3_title": "Optional: Pro mode for full scan", + "step3_text": "If you need more detail, install the optional helper tool. It can test the entire capacity, spot fakes and generate detailed reports – ideal for refurbishers, IT teams or labs.", + "side_title": "Free vs. Pro at a glance", + "side_free": "Free quick check: Browser speed & integrity test – ideal for quick assessments.", + "side_pro": "Pro mode: Deep scan, capacity validation, extended reports and API integration for businesses.", + "side_account": "Account & login: After logging in you can save tests, export reports and manage multiple devices." + }, + "problem": { + "kicker": "Why fake USB drives are risky", + "title": "Fake drives cost money – and worst case your data.", + "p1": "Many cheap drives advertise unrealistic capacity. Controllers are manipulated: a stick claims 256 GB even though only 32 GB are physically present. Files appear to copy fine but later get silently overwritten or corrupted.", + "p2": "USBCheck helps you spot these fakes before you rely on them – whether you use drives privately or check larger batches for your company.", + "card1_title": "Loss of important files", + "card1_text": "Photos, project files, backups – everything is at risk when the drive stores less than promised. Defective sectors often stay unnoticed until it’s too late.", + "card2_title": "Costs from bad batches", + "card2_text": "Businesses, resellers and agencies hand out drives in volume. Fakes mean complaints, reputation damage and re-production costs.", + "card3_title": "Unreliable performance", + "card3_text": "Slow controllers, unstable firmware and fluctuating write speeds are typical for fake drives. That raises the risk of errors – especially with large files." + }, + "features": { + "kicker": "Free & Pro features", + "title": "Start with the free quick check – switch to Pro when you need more.", + "intro": "USBCheck grows with your needs: private users usually just need a quick verdict. Pros want full insight, verify capacity and archive reports. That’s what Pro mode is for.", + "free_title": "Free quick check", + "free_badge": "Recommended for most users", + "free_text": "Perfect for anyone who wants to see if a drive runs decently fast and stable – without installing anything.", + "free_li1": "• Browser-based quick check directly on your drive", + "free_li2": "• Write/read speed with real test data", + "free_li3": "• Hash-based integrity check of a sample size", + "free_li4": "• Pick from different test levels (e.g. 200 MB, 2 GB)", + "free_li5": "• No registration required", + "free_cta": "Start free quick check", + "pro_title": "Pro mode", + "pro_badge": "For power users & teams", + "pro_text": "For IT departments, technicians, refurbishers or companies testing larger volumes who need full control.", + "pro_li1": "• Deep scan of the entire capacity (similar to F3/badblocks)", + "pro_li2": "• Detects capacity fakes and defective areas", + "pro_li3": "• Detailed, savable test reports (JSON, PDF)", + "pro_li4": "• Optional API access for automated workflows", + "pro_li5": "• Multi-device and multi-user support via the login area", + "pro_note": "Pro mode requires a small helper tool on your system. It runs locally and can link with your USBCheck account if needed." + }, + "security": { + "kicker": "Security & privacy", + "title": "Privacy-first design: your test data belongs to you.", + "intro": "USBCheck was built so your data stays protected. The browser quick check only uses test files. Your own documents, photos or backups are neither read nor uploaded. In Pro mode you decide if and which reports sync with your account.", + "card1_title": "Local-only tests", + "card1_text": "All write/read tests happen locally on your drive. The browser only touches the test files – not your personal content.", + "card2_title": "Transparent reports", + "card2_text": "If you log in you can store reports in your account, export them or delete them again. You decide what stays in the system.", + "card3_title": "Gentle on your hardware", + "card3_text": "The quick check uses moderate data sizes to avoid unnecessary wear. Pro mode clearly warns when a full, write-heavy scan is triggered." + }, + "faq": { + "kicker": "FAQ", + "title": "Frequently asked questions about USBCheck", + "intro": "Here are answers to common questions. Expand the FAQ any time when new use cases appear or you receive user feedback.", + "q1": "Is the quick check completely in the browser?", + "a1": "Yes. The quick check runs fully inside the browser and uses modern APIs to write and read test files on your drive. Nothing is uploaded without your consent.", + "q2": "Do I need an account to use the quick check?", + "a2": "No. The free quick check works without registration. Login is only needed if you want to save reports, manage multiple drives or use Pro mode.", + "q3": "Can USBCheck reliably detect every fake drive?", + "a3": "No tool can promise 100%. The Pro mode with full scan is built to detect the typical manipulation patterns (reported capacity vs. physical, unstable zones, errors after certain fill levels) very reliably.", + "q4": "How does the tool fit into my workflow?", + "a4": "USBCheck is designed for automation. Via Pro mode and the planned API you can integrate tests into existing workflows – e.g. incoming goods checks or QA." + } + } + }, + "fakecheck": { + "meta": { + "title": "FakeCheck – Browser test for USB drives", + "description": "FakeCheck helps you uncover typical fake drives: browser-based write/read tests and plausibility checks of usable capacity – no install required." + }, + "sections": { + "hero": { + "kicker": "FakeCheck – browser mode", + "title": "Is my USB drive fake?", + "lead": "FakeCheck helps you uncover typical fake drives: browser-based write/read tests and capacity plausibility checks – without installation.", + "cta_start": "Start browser test (demo)", + "cta_back_home": "Back to overview", + "hint": "The FakeCheck browser mode works with test files and read/write patterns that you create in a selected folder. Your real files stay untouched." + }, + "capabilities": { + "title": "What the browser test can do", + "point1_title": "Write/read test with test files", + "point1_text": "The browser creates test files in the selected folder, measures write/read speeds and checks whether read data matches the written patterns.", + "point2_title": "Capacity plausibility check", + "point2_text": "The amount of data written and verified gives you a realistic idea of how much usable capacity is actually stable.", + "point3_title": "JSON report for documentation", + "point3_text": "All results go into a structured JSON report you can save, upload or reuse later." + }, + "app": { + "title": "Browser test interface (preview)", + "intro": "Here’s where the FakeCheck web app will live: pick a folder, configure the test amount, see progress and the result panel. For now the button above shows a demo output.", + "point1": "Quick test with a small data set.", + "point2": "Light benchmark: write/read speed over a limited time.", + "point3": "Write/Verify: write test files and immediately verify them." + }, + "result": { + "title": "Demo output of the browser test", + "hint": "This output is just a preview. Later the real JSON report from the browser test will appear here." + } + } + }, + "login": { + "meta": { + "title": "Login – {{primary_domain}}", + "description": "Sign in to {{primary_domain}} to save tests, use Pro mode and manage multiple devices." + }, + "sections": { + "auth": { + "kicker": "Account & login", + "title": "Sign in to USBCheck", + "intro": "With an account you can save tests, export reports and use Pro mode across multiple devices. Registration is free – upgrade to Pro later any time.", + "tab_login": "Login", + "tab_register": "Register", + "login_title": "Login", + "login_text": "Sign in with your email address and password.", + "login_email_label": "Email address", + "login_password_label": "Password", + "login_submit": "Sign in", + "login_forgot": "Forgot password?", + "register_title": "Register for free", + "register_text": "Create a free account to save tests, export reports and unlock Pro mode later.", + "register_name_label": "Name", + "register_email_label": "Email address", + "register_password_label": "Password", + "register_submit": "Create account", + "register_hint": "By registering you accept the privacy policy and legal notice of USBCheck." + } + } + }, + "dashboard": { + "meta": { + "title": "Dashboard – {{primary_domain}}", + "description": "Manage your USB tests, devices and Pro mode settings in your personal dashboard." + }, + "sections": { + "main": { + "kicker": "Dashboard", + "title": "Welcome", + "intro": "Manage your USB tests, keep devices organized and soon enable Pro mode. This area is still under construction – but you already get a first glimpse.", + "plan_label": "Current plan", + "card_tests_title": "Latest tests", + "card_tests_text": "Your latest quick checks and Pro scans will appear here – including status, speed and integrity info.", + "card_tests_empty": "No test data yet. Start your first test via the browser or Pro mode.", + "card_devices_title": "Your USB devices", + "card_devices_text": "Soon you’ll manage tested drives here: manufacturer, model, serial number and detected capacity.", + "card_devices_empty": "No devices stored yet. After your first tests you can add USB drives here.", + "card_next_title": "Next steps", + "card_next_text": "USBCheck is still evolving. You’re among the first users – later you’ll find Pro options, API access and detailed reports here.", + "card_next_item1": "• Try the browser FakeCheck and share feedback", + "card_next_item2": "• Define Pro mode features (e.g. full scan, reports, API)", + "card_next_item3": "• Finalize accounts & SSO (my-log.in)", + "card_next_cta": "Go to browser FakeCheck" + } } } }