@jjlmoya/utils-tools 1.1.0

package/src/tool/morse-beacon/i18n/es.ts

@@ -0,0 +1,157 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { MorseBeaconUI } from '../ui';
+
+const faqData = [
+  {
+    question: '¿Cuál es la señal de socorro SOS en código Morse?',
+    answer: "La señal es '... --- ...' (tres puntos, tres rayas, tres puntos). Se transmite de forma continua sin espacios entre las letras para indicar una emergencia inmediata.",
+  },
+  {
+    question: '¿Por qué no funciona el flash en mi navegador?',
+    answer: 'La activación del flash (Torch) requiere que el navegador tenga permisos de cámara. Algunos navegadores móviles o versiones antiguas de escritorio no soportan esta API por motivos de privacidad.',
+  },
+  {
+    question: '¿Es visible la señal de SOS de la pantalla?',
+    answer: 'Sí, en condiciones de oscuridad absoluta, el brillo máximo de una pantalla blanca parpadeando en Morse puede verse a varios cientos de metros de distancia, siendo una alternativa útil si el flash falla.',
+  },
+  {
+    question: '¿Qué es el código Morse internacional?',
+    answer: 'Es un sistema de comunicación que utiliza secuencias de señales cortas (puntos) y largas (rayas) para representar letras y números, estandarizado por la UIT para comunicaciones de radio y señales ópticas.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Escribir el mensaje',
+    text: "Introduce el texto que quieres transmitir o utiliza el botón preconfigurado de 'SOS' para emergencias.",
+  },
+  {
+    name: 'Configurar la velocidad',
+    text: 'Ajusta los WPM (palabras por minuto) para que la señal sea más rápida o más lenta según la visibilidad.',
+  },
+  {
+    name: 'Elegir fuente de luz',
+    text: 'Activa el parpadeo de la pantalla completa o permite el acceso al flash de la cámara para una señal más potente.',
+  },
+  {
+    name: 'Iniciar transmisión',
+    text: 'Pulsa Transmitir para que el sistema convierta el texto en impulsos visuales automáticos siguiendo el estándar Morse.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Cómo usar la baliza Morse para transmitir mensajes',
+  step: howToData.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'Baliza Morse: Transmisor Táctico SOS',
+  applicationCategory: 'UtilitiesApplication',
+  operatingSystem: 'Web',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  description: 'Convierte tu dispositivo en una estación de transmisión Morse. Utiliza flash y pantalla como señales de luz de emergencia y comunicación táctica.',
+};
+
+const ui: MorseBeaconUI = {
+  labelMessage: 'Mensaje a Transmitir',
+  placeholder: 'Escribe aquí tu mensaje (SOS, HOLA, AYUDA)...',
+  btnTransmit: 'Transmitir',
+  btnSosLoop: 'Bucle SOS',
+  btnStop: 'Detener',
+  labelTorch: 'Flash/Linterna',
+  statusStandby: 'STANDBY',
+  statusTransmitting: 'TRANSMITIENDO',
+  statusStopping: 'DETENIENDO...',
+  statusWaiting: 'EN ESPERA',
+  statusReady: 'HARDWARE LISTO',
+  statusNoTorch: 'SIN LINTERNA',
+  statusNoPermission: 'SIN PERMISO',
+  statusNotSupported: 'NO SOPORTADO',
+  statusReqHttps: 'REQ. HTTPS',
+  statusSending: 'ENVIANDO:',
+};
+
+export const content: ToolLocaleContent<MorseBeaconUI> = {
+  slug: 'baliza-morse',
+  title: 'Baliza Morse: Transmisor Táctico SOS',
+  description: 'Convierte tu dispositivo en una estación de transmisión Morse. Utiliza flash y pantalla como señales de luz de emergencia y comunicación táctica.',
+  ui,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  howTo: howToData,
+  bibliographyTitle: 'Referencias',
+  bibliography: [
+    { name: 'ITU-R M.1677-1 — International Morse Code', url: 'https://www.itu.int/dms_pubrec/itu-r/rec/m/R-REC-M.1677-1-200910-I!!PDF-E.pdf' },
+    { name: 'W3C MediaCapture Image — Torch', url: 'https://w3c.github.io/mediacapture-image/#torch' },
+    { name: 'Código Morse — Wikipedia', url: 'https://es.wikipedia.org/wiki/C%C3%B3digo_Morse' },
+  ],
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'El Lenguaje de la Luz',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Esta herramienta convierte tu dispositivo en una baliza de señalización óptica capaz de transmitir mensajes visibles a kilómetros de distancia. Utilizando el estándar internacional del Código Morse, permite la comunicación silenciosa o de emergencia mediante pulsos de luz (linterna y pantalla).',
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          icon: 'mdi:history',
+          title: 'Un Estándar Universal',
+          description: 'Desarrollado en 1830 por Samuel Morse, este sistema binario de puntos y rayas revolucionó las telecomunicaciones. Su simplicidad lo hace extremadamente robusto: puede transmitirse por sonido, radio, electricidad o luz, siendo legible incluso con interferencias severas.',
+          points: [],
+        },
+        {
+          icon: 'mdi:flash-alert',
+          title: 'Modo SOS de Emergencia',
+          description: "El botón 'Bucle SOS' transmite continuamente la secuencia ··· --- ···. Esta señal es reconocida mundialmente como petición de auxilio y, gracias al alto contraste del flash LED, es visible a gran distancia incluso a plena luz del día en ciertas condiciones.",
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Estándar ITU-R M.1677-1',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Esta utilidad respeta estrictamente los <strong>tiempos reglamentarios</strong> del código Morse internacional definidos por la Unión Internacional de Telecomunicaciones.',
+    },
+    {
+      type: 'list',
+      items: [
+        '1 punto = 1 unidad de tiempo',
+        '1 raya = 3 unidades de tiempo',
+        'Espacio entre elementos = 1 unidad',
+        'Espacio entre letras = 3 unidades',
+        'Espacio entre palabras = 7 unidades',
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Velocidad estándar',
+      html: 'La velocidad por defecto es de <strong>15 WPM</strong> (palabras por minuto), que corresponde a un ritmo de transmisión profesional. A 15 WPM, 1 unidad = 80 ms.',
+    },
+  ],
+};

package/src/tool/morse-beacon/i18n/fr.ts

@@ -0,0 +1,157 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { MorseBeaconUI } from '../ui';
+
+const faqData = [
+  {
+    question: 'Quel est le signal de détresse SOS en code Morse ?',
+    answer: "Le signal est '... --- ...' (trois points, trois traits, trois points). Il est transmis en continu sans espaces entre les lettres pour indiquer une urgence immédiate.",
+  },
+  {
+    question: 'Pourquoi la torche ne fonctionne-t-elle pas dans mon navigateur ?',
+    answer: "L'activation de la torche nécessite que le navigateur dispose des autorisations de la caméra. Certains navigateurs mobiles ou les anciennes versions de bureau ne prennent pas en charge cette API pour des raisons de confidentialité.",
+  },
+  {
+    question: "Le signal SOS de l'écran est-il visible ?",
+    answer: "Oui, dans des conditions d'obscurité totale, la luminosité maximale d'un écran blanc clignotant en Morse peut être vue à plusieurs centaines de mètres, ce qui en fait une alternative utile si la torche est défaillante.",
+  },
+  {
+    question: "Qu'est-ce que le code Morse international ?",
+    answer: "C'est un système de communication qui utilise des séquences de signaux courts (points) et longs (traits) pour représenter des lettres et des chiffres, normalisé par l'UIT pour les communications radio et les signaux optiques.",
+  },
+];
+
+const howToData = [
+  {
+    name: 'Écrire le message',
+    text: "Saisissez le texte que vous souhaitez transmettre ou utilisez le bouton préconfiguré 'SOS' pour les urgences.",
+  },
+  {
+    name: 'Configurer la vitesse',
+    text: 'Ajustez les MPM (mots par minute) pour rendre le signal plus rapide ou plus lent selon la visibilité.',
+  },
+  {
+    name: 'Choisir la source de lumière',
+    text: "Activez le clignotement en plein écran ou autorisez l'accès à la torche de l'appareil photo pour un signal plus puissant.",
+  },
+  {
+    name: 'Démarrer la transmission',
+    text: 'Appuyez sur Transmettre pour que le système convertisse le texte en impulsions visuelles automatiques selon la norme Morse.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Comment utiliser la balise Morse pour transmettre des messages',
+  step: howToData.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'Balise Morse : Émetteur tactique SOS',
+  applicationCategory: 'UtilitiesApplication',
+  operatingSystem: 'Web',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  description: 'Transformez votre appareil en station d\'émission Morse. Utilisez le flash et l\'écran comme signaux lumineux d\'urgence et de communication tactique.',
+};
+
+const ui: MorseBeaconUI = {
+  labelMessage: 'Message à transmettre',
+  placeholder: 'Tapez votre message ici (SOS, BONJOUR, AIDE)...',
+  btnTransmit: 'Transmettre',
+  btnSosLoop: 'Boucle SOS',
+  btnStop: 'Arrêter',
+  labelTorch: 'Flash/Lampe',
+  statusStandby: 'EN VEILLE',
+  statusTransmitting: 'TRANSMISSION',
+  statusStopping: 'ARRÊT...',
+  statusWaiting: 'EN ATTENTE',
+  statusReady: 'MATÉRIEL PRÊT',
+  statusNoTorch: 'SANS LAMPE',
+  statusNoPermission: 'SANS PERMISSION',
+  statusNotSupported: 'NON SUPPORTÉ',
+  statusReqHttps: 'REQ. HTTPS',
+  statusSending: 'ENVOI :',
+};
+
+export const content: ToolLocaleContent<MorseBeaconUI> = {
+  slug: 'balise-morse',
+  title: 'Balise Morse : Émetteur tactique SOS',
+  description: "Transformez votre appareil en station d'émission Morse. Utilisez le flash et l'écran comme signaux lumineux d'urgence et de communication tactique.",
+  ui,
+  faqTitle: 'Questions fréquentes',
+  faq: faqData,
+  howTo: howToData,
+  bibliographyTitle: 'Références',
+  bibliography: [
+    { name: 'ITU-R M.1677-1 — Code Morse international', url: 'https://www.itu.int/dms_pubrec/itu-r/rec/m/R-REC-M.1677-1-200910-I!!PDF-E.pdf' },
+    { name: 'W3C MediaCapture Image — Torch', url: 'https://w3c.github.io/mediacapture-image/#torch' },
+    { name: 'Code Morse — Wikipédia', url: 'https://fr.wikipedia.org/wiki/Code_Morse_international' },
+  ],
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Le langage de la lumière',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: "Cet outil transforme votre appareil en balise de signalisation optique capable de transmettre des messages visibles à des kilomètres de distance. En utilisant la norme internationale du code Morse, il permet une communication silencieuse ou d'urgence par impulsions lumineuses (lampe de poche et écran).",
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          icon: 'mdi:history',
+          title: 'Une norme universelle',
+          description: "Développé en 1830 par Samuel Morse, ce système binaire de points et de traits a révolutionné les télécommunications. Sa simplicité le rend extrêmement robuste : il peut être transmis par le son, la radio, l'électricité ou la lumière, et reste lisible même avec de fortes interférences.",
+          points: [],
+        },
+        {
+          icon: 'mdi:flash-alert',
+          title: "Mode d'urgence SOS",
+          description: "Le bouton 'Boucle SOS' transmet en continu la séquence ··· --- ···. Ce signal est universellement reconnu comme appel de détresse et, grâce au contraste élevé du flash LED, est visible à grande distance même en plein jour dans certaines conditions.",
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Norme ITU-R M.1677-1',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: "Cet outil respecte strictement les <strong>délais réglementaires</strong> du code Morse international tels que définis par l'Union internationale des télécommunications.",
+    },
+    {
+      type: 'list',
+      items: [
+        '1 point = 1 unité de temps',
+        '1 trait = 3 unités de temps',
+        'Espace entre éléments = 1 unité',
+        'Espace entre lettres = 3 unités',
+        'Espace entre mots = 7 unités',
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Vitesse standard',
+      html: 'La vitesse par défaut est de <strong>15 MPM</strong> (mots par minute), ce qui correspond à un rythme de transmission professionnel. À 15 MPM, 1 unité = 80 ms.',
+    },
+  ],
+};

package/src/tool/morse-beacon/index.ts

@@ -0,0 +1,22 @@
+import type { ToolDefinition, ToolsToolEntry } from '../../types';
+import type { MorseBeaconUI } from './ui';
+import MorseBeaconComponent from './component.astro';
+import MorseBeaconSEO from './seo.astro';
+import MorseBeaconBibliography from './bibliography.astro';
+
+export const morseBeacon: ToolsToolEntry<MorseBeaconUI> = {
+  id: 'morse-beacon',
+  icons: { bg: 'mdi:transmission-tower', fg: 'mdi:dots-horizontal' },
+  i18n: {
+    es: () => import('./i18n/es').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+  },
+};
+
+export const MORSE_BEACON_TOOL: ToolDefinition = {
+  entry: morseBeacon,
+  Component: MorseBeaconComponent,
+  SEOComponent: MorseBeaconSEO,
+  BibliographyComponent: MorseBeaconBibliography,
+};

package/src/tool/morse-beacon/logic/MorseEngine.ts

@@ -0,0 +1,124 @@
+export type MorseSignal = '.' | '-' | ' ';
+
+export const MORSE_DICTIONARY: Record<string, string> = {
+  A: '.-', B: '-...', C: '-.-.', D: '-..', E: '.', F: '..-.', G: '--.', H: '....',
+  I: '..', J: '.---', K: '-.-', L: '.-..', M: '--', N: '-.', O: '---', P: '.--.',
+  Q: '--.-', R: '.-.', S: '...', T: '-', U: '..-', V: '...-', W: '.--', X: '-..-',
+  Y: '-.--', Z: '--..',
+  '1': '.----', '2': '..---', '3': '...--', '4': '....-', '5': '.....',
+  '6': '-....', '7': '--...', '8': '---..', '9': '----.', '0': '-----',
+  '.': '.-.-.-', ',': '--..--', '?': '..--..', "'": '.----.', '!': '-.-.--',
+  '/': '-..-.', '(': '-.--.', ')': '-.--.-', '&': '.-...', ':': '---...',
+  ';': '-.-.-.', '=': '-...-', '+': '.-.-.', '-': '-....-', _: '..--.-',
+  '"': '.-..-.', $: '...-..-', '@': '.--.-.',
+};
+
+export type MorseBitType = 'dot' | 'dash' | 'gap' | 'charSpace' | 'wordSpace';
+
+export class MorseBit {
+  type: MorseBitType;
+  duration: number;
+  isActive: boolean;
+
+  constructor(type: MorseBitType, unit: number) {
+    this.type = type;
+    this.isActive = type === 'dot' || type === 'dash';
+
+    const durations: Record<MorseBitType, number> = {
+      dot: unit, dash: unit * 3, gap: unit, charSpace: unit * 3, wordSpace: unit * 7,
+    };
+    this.duration = durations[type];
+  }
+}
+
+export class MorseEngine {
+  private unit: number;
+  private isPlaying = false;
+  private stopSignal = false;
+  private onStateChange: (active: boolean, bit: MorseBit | null) => void;
+
+  constructor(wpm = 15, onStateChange: (active: boolean, bit: MorseBit | null) => void) {
+    this.unit = 1200 / wpm;
+    this.onStateChange = onStateChange;
+  }
+
+  static textToMorse(text: string): string {
+    return text.toUpperCase().split('').map((char) => {
+      if (char === ' ') return '/';
+      return MORSE_DICTIONARY[char] ?? '?';
+    }).join(' ');
+  }
+
+  private static compileCharBits(bits: string[], unit: number, addSpace: boolean): MorseBit[] {
+    const result: MorseBit[] = [];
+    for (let j = 0; j < bits.length; j++) {
+      const bit = bits[j];
+      if (bit === '.') result.push(new MorseBit('dot', unit));
+      if (bit === '-') result.push(new MorseBit('dash', unit));
+      if (j < bits.length - 1) result.push(new MorseBit('gap', unit));
+    }
+    if (addSpace) result.push(new MorseBit('charSpace', unit));
+    return result;
+  }
+
+  static compileSequence(text: string, wpm: number): MorseBit[] {
+    const unit = 1200 / wpm;
+    const sequence: MorseBit[] = [];
+    const normalized = text.toUpperCase();
+
+    for (let i = 0; i < normalized.length; i++) {
+      const char = normalized[i];
+      if (!char) continue;
+
+      if (char === ' ') {
+        sequence.push(new MorseBit('wordSpace', unit));
+        continue;
+      }
+
+      const code = MORSE_DICTIONARY[char];
+      if (!code) continue;
+
+      const nextChar = normalized[i + 1];
+      const addSpace = i < normalized.length - 1 && nextChar !== ' ';
+      sequence.push(...MorseEngine.compileCharBits(code.split(''), unit, addSpace));
+    }
+
+    return sequence;
+  }
+
+  stop() { this.stopSignal = true; }
+
+  private async playBit(bit: MorseBit): Promise<void> {
+    this.onStateChange(bit.isActive, bit);
+    if (bit.isActive && navigator.vibrate) navigator.vibrate(bit.duration);
+    await this.wait(bit.duration);
+    if (bit.isActive) this.onStateChange(false, null);
+  }
+
+  private async playOnce(sequence: MorseBit[]): Promise<void> {
+    for (const bit of sequence) {
+      if (this.stopSignal) break;
+      await this.playBit(bit);
+    }
+  }
+
+  async transmit(sequence: MorseBit[], loop = false): Promise<void> {
+    if (this.isPlaying) return;
+    this.isPlaying = true;
+    this.stopSignal = false;
+
+    do {
+      await this.playOnce(sequence);
+      if (loop && !this.stopSignal) await this.wait(this.unit * 7);
+    } while (loop && !this.stopSignal);
+
+    this.isPlaying = false;
+    this.onStateChange(false, null);
+  }
+
+  private wait(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  isActive(): boolean { return this.isPlaying; }
+}

package/src/tool/morse-beacon/seo.astro

@@ -0,0 +1,14 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { morseBeacon } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await morseBeacon.i18n[locale]?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/morse-beacon/ui.ts

@@ -0,0 +1,18 @@
+export interface MorseBeaconUI extends Record<string, string> {
+  labelMessage: string;
+  placeholder: string;
+  btnTransmit: string;
+  btnSosLoop: string;
+  btnStop: string;
+  labelTorch: string;
+  statusStandby: string;
+  statusTransmitting: string;
+  statusStopping: string;
+  statusWaiting: string;
+  statusReady: string;
+  statusNoTorch: string;
+  statusNoPermission: string;
+  statusNotSupported: string;
+  statusReqHttps: string;
+  statusSending: string;
+}

package/src/tool/password-generator/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { passwordGenerator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await passwordGenerator.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}