@jjlmoya/utils-developer 1.2.0

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

@@ -0,0 +1,191 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CronGeneratorUI } from '../ui';
+
+const slug = 'cron';
+const title = 'Online Cron Expression Generator. Translator and Visualizer';
+const description =
+  'Free visual tool to generate Linux Cron expressions. Translates * * * * * into human language and shows the next 5 executions in real time.';
+
+const faqData = [
+  {
+    question: 'What is a Cron expression?',
+    answer:
+      'It is a text string that represents an execution schedule for automatic tasks on Unix-like systems (Linux, macOS). It consists of 5 fields that define minutes, hours, day of month, month, and day of week.',
+  },
+  {
+    question: 'Is it compatible with all systems?',
+    answer:
+      'Yes, the generated expressions follow the POSIX standard, compatible with Linux Crontab, macOS crons, and cloud services like AWS CloudWatch or GitHub Actions.',
+  },
+  {
+    question: 'What does the asterisk (*) mean in Cron?',
+    answer:
+      'The asterisk is a wildcard meaning "all". For example, a * in the minutes field means the task will run every minute of the defined range.',
+  },
+  {
+    question: 'How can I check the upcoming executions?',
+    answer:
+      'The tool includes a real-time viewer showing exactly the next 5 dates and times when your task will run according to the current expression.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Select the interval',
+    text: 'Choose how often you want the task to run using the quick presets (every minute, every hour, daily, etc.).',
+  },
+  {
+    name: 'Configure advanced details',
+    text: 'Switch to the "Advanced" tab to manually define the exact minutes, hours, or specific days of the week.',
+  },
+  {
+    name: 'Verify the translation and dates',
+    text: 'Read the human-language description and check the next 5 executions to confirm the schedule is correct.',
+  },
+  {
+    name: 'Copy the expression',
+    text: 'Copy the resulting string and paste it directly into your crontab file or server configuration.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'en',
+};
+
+const ui: CronGeneratorUI = {
+  labelMinute: 'Minute',
+  labelHour: 'Hour',
+  labelDom: 'Day (Month)',
+  labelMonth: 'Month',
+  labelDow: 'Day (Week)',
+  tabQuick: 'Quick',
+  tabAdvanced: 'Advanced',
+  fieldMinute: 'Minute (0-59)',
+  fieldHour: 'Hour (0-23)',
+  fieldDom: 'Day of Month (1-31)',
+  fieldMonth: 'Month (1-12)',
+  fieldDow: 'Day of Week (0-6)',
+  hintMinute: 'E.g.: *, */5, 0,30',
+  hintDow: '0 = Sunday, 6 = Saturday',
+  labelNextRuns: 'Next Executions',
+  btnCopy: 'Copy Expression',
+  btnCopied: 'Copied!',
+  msgNoRuns: 'No upcoming executions found within a reasonable range.',
+  msgError: 'Error calculating dates.',
+  presetEveryMinute: 'Every minute',
+  presetEveryHour: 'Every hour',
+  presetDaily: 'Daily',
+  presetWeekly: 'Weekly',
+  presetMonthly: 'Monthly',
+  presetYearly: 'Yearly',
+  descEveryMinute: 'Runs every minute',
+  descEveryHour: 'Runs at the start of every hour',
+  descEveryDay: 'Runs every day at midnight',
+  descPrefix: 'Runs',
+  descEveryMin: 'every minute',
+  descEveryHourOnDot: 'every hour on the dot',
+  descAtMinute: 'at minute {m} of every hour',
+  descAtTime: 'at {h}:{m}',
+  descOnDay: ' on day {d} of the month',
+  descInMonth: ' in month {mon}',
+  descIfDow: ' if it is day {d} (0=Sun, 6=Sat)',
+  descDays: 'Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday',
+  descInvalid: 'Invalid expression',
+  timeNow: 'now',
+  timeMin: 'min',
+  timeHour: 'h',
+  timeDays: 'days',
+  locale: 'en-US',
+};
+
+export const content: ToolLocaleContent<CronGeneratorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'References and Documentation',
+  bibliography: [
+    {
+      name: 'GNU Crontab Manual: Cron Expressions on Linux',
+      url: 'https://www.gnu.org/software/mcron/manual/html_node/Crontab-file.html',
+    },
+    {
+      name: 'Cron on Wikipedia: History and Syntax',
+      url: 'https://en.wikipedia.org/wiki/Cron',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'The Importance of Cron in Modern Automation',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Despite living in the age of <em>serverless</em> servers and cloud workflows, the <strong>Crontab</strong> system remains the backbone of global technology infrastructure. From small blogs to massive banking infrastructures, task scheduling is what keeps the digital world running.',
+    },
+    {
+      type: 'title',
+      text: 'Anatomy of a Cron Expression',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Field 1 - Minute (0-59):</strong> When the task starts within the hour.',
+        '<strong>Field 2 - Hour (0-23):</strong> 24-hour format required.',
+        '<strong>Field 3 - Day of Month (1-31):</strong> Specific calendar day.',
+        '<strong>Field 4 - Month (1-12):</strong> From January to December.',
+        '<strong>Field 5 - Day of Week (0-6):</strong> 0 is typically Sunday.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Special operators and common mistakes',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Use the slash <code>/</code> to define steps: <code>*/5</code> in minutes runs every 5 minutes. The comma <code>,</code> creates lists (<code>1,3,5</code>) and the hyphen <code>-</code> defines ranges (<code>1-5</code>).',
+    },
+    {
+      type: 'paragraph',
+      html: '90% of servers run on <strong>UTC</strong>. If you schedule a task at 02:00 AM thinking in your local timezone, it may run at an unexpected time. Also, Cron does not have access to your usual <code>$PATH</code> — always use absolute paths like <code>/usr/local/bin/node</code>.',
+    },
+  ],
+};

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

@@ -0,0 +1,191 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CronGeneratorUI } from '../ui';
+
+const slug = 'cron';
+const title = 'Generador de Expresiones Cron Online. Traductor y Visualizador';
+const description =
+  'Herramienta visual gratuita para generar expresiones Cron de Linux. Traduce * * * * * a lenguaje humano y visualiza las próximas 5 ejecuciones en tiempo real.';
+
+const faqData = [
+  {
+    question: '¿Qué es una expresión Cron?',
+    answer:
+      'Es una cadena de texto que representa un horario de ejecución para tareas automáticas en sistemas tipo Unix (Linux, macOS). Se compone de 5 campos que definen minutos, horas, días del mes, meses y días de la semana.',
+  },
+  {
+    question: '¿Es compatible con todos los sistemas?',
+    answer:
+      'Sí, las expresiones generadas siguen el estándar POSIX, compatible con Crontab de Linux, crons de macOS, y servicios cloud como AWS CloudWatch o GitHub Actions.',
+  },
+  {
+    question: '¿Qué significa el asterisco (*) en Cron?',
+    answer:
+      'El asterisco es un comodín que significa "todos". Por ejemplo, un * en el campo de los minutos indica que la tarea se ejecutará cada minuto del rango definido.',
+  },
+  {
+    question: '¿Cómo puedo verificar las próximas ejecuciones?',
+    answer:
+      'La herramienta incluye un visor en tiempo real que muestra exactamente las próximas 5 fechas y horas en las que se activará tu tarea según la expresión actual.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Seleccionar el intervalo',
+    text: 'Elige con qué frecuencia quieres que se ejecute la tarea usando los presets rápidos (cada minuto, cada hora, diariamente, etc.).',
+  },
+  {
+    name: 'Configurar detalles avanzados',
+    text: 'Cambia a la pestaña "Avanzado" para definir manualmente los minutos, horas o días de la semana específicos.',
+  },
+  {
+    name: 'Verificar la traducción y las fechas',
+    text: 'Lee la descripción en lenguaje humano y revisa las próximas 5 ejecuciones para confirmar que el horario es correcto.',
+  },
+  {
+    name: 'Copiar expresión',
+    text: 'Copia la cadena resultante y pégala directamente en tu archivo crontab o configuración de servidor.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'es',
+};
+
+const ui: CronGeneratorUI = {
+  labelMinute: 'Minuto',
+  labelHour: 'Hora',
+  labelDom: 'Día (Mes)',
+  labelMonth: 'Mes',
+  labelDow: 'Día (Semana)',
+  tabQuick: 'Rápido',
+  tabAdvanced: 'Avanzado',
+  fieldMinute: 'Minuto (0-59)',
+  fieldHour: 'Hora (0-23)',
+  fieldDom: 'Día del Mes (1-31)',
+  fieldMonth: 'Mes (1-12)',
+  fieldDow: 'Día de la Semana (0-6)',
+  hintMinute: 'Ej: *, */5, 0,30',
+  hintDow: '0 = Domingo, 6 = Sábado',
+  labelNextRuns: 'Próximas Ejecuciones',
+  btnCopy: 'Copiar Expresión',
+  btnCopied: 'Copiado!',
+  msgNoRuns: 'No se encontraron ejecuciones próximas razonables.',
+  msgError: 'Error al calcular fechas.',
+  presetEveryMinute: 'Cada minuto',
+  presetEveryHour: 'Cada hora',
+  presetDaily: 'Diario',
+  presetWeekly: 'Semanal',
+  presetMonthly: 'Mensual',
+  presetYearly: 'Anual',
+  descEveryMinute: 'Se ejecuta cada minuto',
+  descEveryHour: 'Se ejecuta al inicio de cada hora',
+  descEveryDay: 'Se ejecuta cada día a medianoche',
+  descPrefix: 'Se ejecuta',
+  descEveryMin: 'cada minuto',
+  descEveryHourOnDot: 'cada hora en punto',
+  descAtMinute: 'en el minuto {m} de cada hora',
+  descAtTime: 'a las {h}:{m}',
+  descOnDay: ' el día {d} del mes',
+  descInMonth: ' en el mes {mon}',
+  descIfDow: ' si es {d} (0=Dom, 6=Sab)',
+  descDays: 'Domingo,Lunes,Martes,Miércoles,Jueves,Viernes,Sábado',
+  descInvalid: 'Expresión inválida',
+  timeNow: 'ahora',
+  timeMin: 'min',
+  timeHour: 'h',
+  timeDays: 'días',
+  locale: 'es-ES',
+};
+
+export const content: ToolLocaleContent<CronGeneratorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Referencias y Documentación',
+  bibliography: [
+    {
+      name: 'GNU Crontab Manual: Expresiones Cron en Linux',
+      url: 'https://www.gnu.org/software/mcron/manual/html_node/Crontab-file.html',
+    },
+    {
+      name: 'Cron en Wikipedia: Historia y Sintaxis',
+      url: 'https://en.wikipedia.org/wiki/Cron',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'La importancia de Cron en la automatización moderna',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'A pesar de vivir en la era de los servidores <em>serverless</em> y los flujos de trabajo en la nube, el sistema <strong>Crontab</strong> sigue siendo la columna vertebral de la infraestructura tecnológica mundial. Desde pequeños blogs hasta gigantescas infraestructuras bancarias, la programación de tareas es lo que permite que el mundo digital no se detenga.',
+    },
+    {
+      type: 'title',
+      text: 'Anatomía de una Expresión Cron',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Campo 1 - Minuto (0-59):</strong> Cuándo empieza la tarea dentro de la hora.',
+        '<strong>Campo 2 - Hora (0-23):</strong> Formato de 24 horas obligatorio.',
+        '<strong>Campo 3 - Día del Mes (1-31):</strong> Día calendario específico.',
+        '<strong>Campo 4 - Mes (1-12):</strong> De enero a diciembre.',
+        '<strong>Campo 5 - Día de la Semana (0-6):</strong> El 0 suele ser Domingo.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Operadores especiales y errores comunes',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Usa la barra <code>/</code> para definir pasos: <code>*/5</code> en minutos ejecuta cada 5 minutos. La coma <code>,</code> crea listas (<code>1,3,5</code>) y el guion <code>-</code> define rangos (<code>1-5</code>).',
+    },
+    {
+      type: 'paragraph',
+      html: 'El 90% de los servidores funcionan en <strong>UTC</strong>. Si programas una tarea a las 02:00 AM pensando en tu horario local, podrías ejecutarla en un momento inesperado. Además, Cron no tiene acceso a tu <code>$PATH</code> habitual — usa siempre rutas absolutas como <code>/usr/local/bin/node</code>.',
+    },
+  ],
+};

package/src/tool/cronGenerator/i18n/fr.ts

@@ -0,0 +1,191 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { CronGeneratorUI } from '../ui';
+
+const slug = 'cron';
+const title = 'Générateur d\'expressions Cron en ligne. Traducteur et visualiseur';
+const description =
+  'Outil visuel gratuit pour générer des expressions Cron Linux. Traduit * * * * * en langage humain et affiche les 5 prochaines exécutions en temps réel.';
+
+const faqData = [
+  {
+    question: 'Qu\'est-ce qu\'une expression Cron ?',
+    answer:
+      'C\'est une chaîne de texte qui représente un calendrier d\'exécution pour des tâches automatiques sur les systèmes de type Unix (Linux, macOS). Elle se compose de 5 champs définissant les minutes, heures, jour du mois, mois et jour de la semaine.',
+  },
+  {
+    question: 'Est-elle compatible avec tous les systèmes ?',
+    answer:
+      'Oui, les expressions générées suivent la norme POSIX, compatible avec Linux Crontab, les crons macOS et les services cloud comme AWS CloudWatch ou GitHub Actions.',
+  },
+  {
+    question: 'Que signifie l\'astérisque (*) dans Cron ?',
+    answer:
+      'L\'astérisque est un caractère générique signifiant "tous". Par exemple, un * dans le champ des minutes indique que la tâche s\'exécutera chaque minute de la plage définie.',
+  },
+  {
+    question: 'Comment vérifier les prochaines exécutions ?',
+    answer:
+      'L\'outil inclut un visualiseur en temps réel affichant exactement les 5 prochaines dates et heures auxquelles votre tâche s\'exécutera selon l\'expression actuelle.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Sélectionner l\'intervalle',
+    text: 'Choisissez la fréquence d\'exécution de la tâche à l\'aide des préréglages rapides (chaque minute, chaque heure, quotidien, etc.).',
+  },
+  {
+    name: 'Configurer les détails avancés',
+    text: 'Passez à l\'onglet "Avancé" pour définir manuellement les minutes, heures ou jours de la semaine spécifiques.',
+  },
+  {
+    name: 'Vérifier la traduction et les dates',
+    text: 'Lisez la description en langage naturel et vérifiez les 5 prochaines exécutions pour confirmer que le calendrier est correct.',
+  },
+  {
+    name: 'Copier l\'expression',
+    text: 'Copiez la chaîne résultante et collez-la directement dans votre fichier crontab ou votre configuration serveur.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'fr',
+};
+
+const ui: CronGeneratorUI = {
+  labelMinute: 'Minute',
+  labelHour: 'Heure',
+  labelDom: 'Jour (Mois)',
+  labelMonth: 'Mois',
+  labelDow: 'Jour (Semaine)',
+  tabQuick: 'Rapide',
+  tabAdvanced: 'Avancé',
+  fieldMinute: 'Minute (0-59)',
+  fieldHour: 'Heure (0-23)',
+  fieldDom: 'Jour du Mois (1-31)',
+  fieldMonth: 'Mois (1-12)',
+  fieldDow: 'Jour de la Semaine (0-6)',
+  hintMinute: 'Ex : *, */5, 0,30',
+  hintDow: '0 = Dimanche, 6 = Samedi',
+  labelNextRuns: 'Prochaines exécutions',
+  btnCopy: 'Copier l\'expression',
+  btnCopied: 'Copié !',
+  msgNoRuns: 'Aucune exécution prochaine trouvée dans un délai raisonnable.',
+  msgError: 'Erreur lors du calcul des dates.',
+  presetEveryMinute: 'Chaque minute',
+  presetEveryHour: 'Chaque heure',
+  presetDaily: 'Quotidien',
+  presetWeekly: 'Hebdomadaire',
+  presetMonthly: 'Mensuel',
+  presetYearly: 'Annuel',
+  descEveryMinute: 'S\'exécute chaque minute',
+  descEveryHour: 'S\'exécute au début de chaque heure',
+  descEveryDay: 'S\'exécute chaque jour à minuit',
+  descPrefix: 'S\'exécute',
+  descEveryMin: 'chaque minute',
+  descEveryHourOnDot: 'chaque heure pile',
+  descAtMinute: 'à la minute {m} de chaque heure',
+  descAtTime: 'à {h}:{m}',
+  descOnDay: ' le jour {d} du mois',
+  descInMonth: ' au mois {mon}',
+  descIfDow: ' si c\'est le jour {d} (0=Dim, 6=Sam)',
+  descDays: 'Dimanche,Lundi,Mardi,Mercredi,Jeudi,Vendredi,Samedi',
+  descInvalid: 'Expression invalide',
+  timeNow: 'maintenant',
+  timeMin: 'min',
+  timeHour: 'h',
+  timeDays: 'jours',
+  locale: 'fr-FR',
+};
+
+export const content: ToolLocaleContent<CronGeneratorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Questions fréquentes',
+  faq: faqData,
+  bibliographyTitle: 'Références et documentation',
+  bibliography: [
+    {
+      name: 'Manuel GNU Crontab : Expressions Cron sous Linux',
+      url: 'https://www.gnu.org/software/mcron/manual/html_node/Crontab-file.html',
+    },
+    {
+      name: 'Cron sur Wikipedia : Histoire et syntaxe',
+      url: 'https://en.wikipedia.org/wiki/Cron',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'L\'importance de Cron dans l\'automatisation moderne',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Malgré l\'ère des serveurs <em>serverless</em> et des flux de travail cloud, le système <strong>Crontab</strong> reste l\'épine dorsale de l\'infrastructure technologique mondiale. Des petits blogs aux grandes infrastructures bancaires, la planification des tâches maintient le monde numérique en marche.',
+    },
+    {
+      type: 'title',
+      text: 'Anatomie d\'une expression Cron',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Champ 1 - Minute (0-59) :</strong> Quand la tâche démarre dans l\'heure.',
+        '<strong>Champ 2 - Heure (0-23) :</strong> Format 24 heures obligatoire.',
+        '<strong>Champ 3 - Jour du Mois (1-31) :</strong> Jour calendaire spécifique.',
+        '<strong>Champ 4 - Mois (1-12) :</strong> De janvier à décembre.',
+        '<strong>Champ 5 - Jour de la Semaine (0-6) :</strong> 0 correspond généralement au Dimanche.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Opérateurs spéciaux et erreurs courantes',
+      level: 3,
+    },
+    {
+      type: 'tip',
+      html: 'Utilisez le slash <code>/</code> pour définir des pas : <code>*/5</code> en minutes s\'exécute toutes les 5 minutes. La virgule <code>,</code> crée des listes (<code>1,3,5</code>) et le tiret <code>-</code> définit des plages (<code>1-5</code>).',
+    },
+    {
+      type: 'paragraph',
+      html: '90% des serveurs fonctionnent en <strong>UTC</strong>. Si vous planifiez une tâche à 02h00 en pensant à votre fuseau local, elle peut s\'exécuter à un moment inattendu. De plus, Cron n\'a pas accès à votre <code>$PATH</code> habituel — utilisez toujours des chemins absolus comme <code>/usr/local/bin/node</code>.',
+    },
+  ],
+};

package/src/tool/cronGenerator/index.ts

@@ -0,0 +1,34 @@
+import type { DeveloperToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import CronGeneratorComponent from './component.astro';
+import CronGeneratorSEO from './seo.astro';
+import CronGeneratorBibliography from './bibliography.astro';
+
+import type { CronGeneratorUI } from './ui';
+
+export type CronGeneratorLocaleContent = ToolLocaleContent<CronGeneratorUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const cronGenerator: DeveloperToolEntry<CronGeneratorUI> = {
+  id: 'cron-generator',
+  icons: {
+    bg: 'mdi:clock-outline',
+    fg: 'mdi:code-braces',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { CronGeneratorComponent, CronGeneratorSEO, CronGeneratorBibliography };
+
+export const CRON_GENERATOR_TOOL: ToolDefinition = {
+  entry: cronGenerator,
+  Component: CronGeneratorComponent,
+  SEOComponent: CronGeneratorSEO,
+  BibliographyComponent: CronGeneratorBibliography,
+};

package/src/tool/cronGenerator/seo.astro

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

package/src/tool/cronGenerator/ui.ts

@@ -0,0 +1,45 @@
+export interface CronGeneratorUI extends Record<string, string> {
+  labelMinute: string;
+  labelHour: string;
+  labelDom: string;
+  labelMonth: string;
+  labelDow: string;
+  tabQuick: string;
+  tabAdvanced: string;
+  fieldMinute: string;
+  fieldHour: string;
+  fieldDom: string;
+  fieldMonth: string;
+  fieldDow: string;
+  hintMinute: string;
+  hintDow: string;
+  labelNextRuns: string;
+  btnCopy: string;
+  btnCopied: string;
+  msgNoRuns: string;
+  msgError: string;
+  presetEveryMinute: string;
+  presetEveryHour: string;
+  presetDaily: string;
+  presetWeekly: string;
+  presetMonthly: string;
+  presetYearly: string;
+  descEveryMinute: string;
+  descEveryHour: string;
+  descEveryDay: string;
+  descPrefix: string;
+  descEveryMin: string;
+  descEveryHourOnDot: string;
+  descAtMinute: string;
+  descAtTime: string;
+  descOnDay: string;
+  descInMonth: string;
+  descIfDow: string;
+  descDays: string;
+  descInvalid: string;
+  timeNow: string;
+  timeMin: string;
+  timeHour: string;
+  timeDays: string;
+  locale: string;
+}

package/src/tool/cssSpecificityCalculator/bibliography.astro

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