@jjlmoya/utils-travel 1.1.0

package/src/tool/mini-adventures/index.ts

@@ -0,0 +1,70 @@
+import type { TravelToolEntry, ToolDefinition } from '../../types';
+import MiniAdventures from './component.astro';
+import MiniAdventuresSEO from './seo.astro';
+import MiniAdventuresBibliography from './bibliography.astro';
+
+export interface AdventureCategory {
+  id: string;
+  label: string;
+  icon: string;
+  color: string;
+  styling: string;
+}
+
+export interface Adventure {
+  id: number;
+  text: string;
+  categoryId: string;
+}
+
+export interface Achievement {
+  id: string;
+  milestone: number;
+  label: string;
+  categoryId: string | 'global';
+  icon: string;
+  description: string;
+}
+
+export interface MiniAdventuresUI {
+  [key: string]: unknown;
+  title: string;
+  homeTitle: string;
+  homeDesc: string;
+  generateBtn: string;
+  anotherBtn: string;
+  doneBtn: string;
+  shareBtn: string;
+  categories: Record<string, AdventureCategory>;
+  adventures: Adventure[];
+  achievements: Achievement[];
+  stats: {
+    adventures: string;
+    badges: string;
+    progress: string;
+    trophies: string;
+  };
+  shareTemplate: string;
+}
+
+export const miniAdventures: TravelToolEntry<MiniAdventuresUI> = {
+  id: 'mini-adventures',
+  icons: {
+    bg: 'mdi:compass-outline',
+    fg: 'mdi:map-marker-distance',
+  },
+  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 { MiniAdventures, MiniAdventuresSEO, MiniAdventuresBibliography };
+
+export const MINI_ADVENTURES_TOOL: ToolDefinition = {
+  entry: miniAdventures,
+  Component: MiniAdventures,
+  SEOComponent: MiniAdventuresSEO,
+  BibliographyComponent: MiniAdventuresBibliography,
+};

package/src/tool/mini-adventures/seo.astro

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

package/src/tool/optimal-routes/bibliography.astro

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

package/src/tool/optimal-routes/component.astro

@@ -0,0 +1,439 @@
+---
+import { Icon } from "astro-icon/components";
+import type { OptimalRoutesUI } from "./index";
+
+interface Props {
+  ui: OptimalRoutesUI;
+}
+
+const { ui } = Astro.props;
+---
+
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.css" integrity="sha512-Zcn6bjR/8RZbHGRqb9iE6RE9asEafS0p/+ftT39eit5Q754u+4nS0N8H6z69D5j5U4y2N8hUf6f0f5j9Q==" crossorigin="anonymous" referrerpolicy="no-referrer" />
+
+<div class="optimal-routes">
+    <div class="or-container">
+        <div class="or-sidebar">
+            <header class="or-sidebar-header">
+                <h3>{ui.sidebar.title}</h3>
+                <button id="or-clear-btn" class="or-btn-clear" title={ui.sidebar.clearBtn}>
+                    <Icon name="mdi:trash-can-outline" />
+                </button>
+            </header>
+
+            <div class="or-points-container">
+                <p class="or-instructions">{ui.sidebar.addPoint}</p>
+                <div id="or-empty-state" class="or-empty">
+                    <Icon name="mdi:map-marker-plus-outline" />
+                    <p>{ui.sidebar.emptyState}</p>
+                </div>
+                <ul id="or-points-list" class="or-list"></ul>
+            </div>
+
+            <div id="or-stats-panel" class="or-stats hidden">
+                <div class="or-stat-item">
+                    <span>{ui.sidebar.stats.distance}</span>
+                    <strong id="or-total-dist">0 km</strong>
+                </div>
+            </div>
+
+            <footer class="or-sidebar-footer">
+                <button id="or-optimize-btn" class="or-btn-primary" disabled>
+                    <Icon name="mdi:auto-fix" />
+                    <span>{ui.sidebar.optimizeBtn}</span>
+                </button>
+            </footer>
+        </div>
+
+        <div class="or-map-wrapper">
+            <div id="or-map" class="or-map-el">
+                <div class="or-map-loader">
+                    <Icon name="mdi:loading" class="animate-spin" />
+                    <p>{ui.map.placeholder}</p>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.9.4/leaflet.js" integrity="sha512-VP/K7V41mX7K3o5u4p0p5U4y2N8hUf6f0f5j9Q==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>
+
+<script is:inline define:vars={{ ui }}>
+    class SimpleRouteManager extends EventTarget {
+        constructor(L) {
+            super();
+            this.L = L;
+            this.points = [];
+            this.routeLine = null;
+        }
+
+        initMap(id) {
+            this.map = this.L.map(id).setView([40.4167, -3.7038], 6);
+            this.L.tileLayer('https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png').addTo(this.map);
+            this.map.on('click', e => this.addPoint(e.latlng.lat, e.latlng.lng));
+        }
+
+        getNumberedIcon(n) {
+            return this.L.divIcon({
+                className: 'or-marker-icon',
+                html: `<div class="or-marker-num">${n}</div>`,
+                iconSize: [30, 30],
+                iconAnchor: [15, 30]
+            });
+        }
+
+        async addPoint(lat, lng) {
+            const id = Date.now();
+            const marker = this.L.marker([lat, lng], {
+                draggable: true,
+                icon: this.getNumberedIcon(this.points.length + 1)
+            }).addTo(this.map);
+
+            const point = { id, lat, lng, marker, name: `Punto` };
+            this.points.push(point);
+            this.notify();
+
+            marker.on('dragend', () => {
+                const pos = marker.getLatLng();
+                point.lat = pos.lat;
+                point.lng = pos.lng;
+                this.notify();
+            });
+
+            try {
+                const res = await fetch(`https://nominatim.openstreetmap.org/reverse?format=json&lat=${lat}&lon=${lng}`);
+                const data = await res.json();
+                point.name = data.display_name.split(',')[0] || 'Punto';
+                this.notify();
+            } catch {}
+        }
+
+        deletePoint(id) {
+            const idx = this.points.findIndex(p => p.id === id);
+            if (idx !== -1) {
+                this.map.removeLayer(this.points[idx].marker);
+                this.points.splice(idx, 1);
+                this.points.forEach((p, i) => p.marker.setIcon(this.getNumberedIcon(i+1)));
+                this.notify();
+            }
+        }
+
+        notify() { this.dispatchEvent(new CustomEvent('update', { detail: this.points })); }
+
+        async optimize() {
+            if (this.points.length < 2) return;
+            this.dispatchEvent(new CustomEvent('loading', { detail: true }));
+
+            try {
+                const coords = this.points.map(p => `${p.lng},${p.lat}`).join(';');
+                const res = await fetch(`https://router.project-osrm.org/trip/v1/driving/${coords}?roundtrip=true&geometries=geojson&overview=full`);
+                const data = await res.json();
+                const waypoints = data.waypoints;
+                const loop = waypoints.map(wp => this.points[wp.waypoint_index]);
+
+                this.points = loop;
+                this.points.forEach((p, i) => p.marker.setIcon(this.getNumberedIcon(i+1)));
+                this.notify();
+
+                if (this.routeLine) this.map.removeLayer(this.routeLine);
+                this.routeLine = this.L.geoJSON(data.trips[0].geometry, {
+                    style: { color: '#0891b2', weight: 5 }
+                }).addTo(this.map);
+                this.map.fitBounds(this.routeLine.getBounds(), { padding: [50, 50] });
+
+                document.getElementById('or-total-dist').textContent = `${(data.trips[0].distance / 1000).toFixed(2)} km`;
+                document.getElementById('or-stats-panel').classList.remove('hidden');
+            } catch {
+            } finally {
+                this.dispatchEvent(new CustomEvent('loading', { detail: false }));
+            }
+        }
+    }
+
+    function setupUpdateListener(manager, btnOpt, listEl, emptyEl) {
+        manager.addEventListener('update', e => {
+            const points = e.detail;
+            btnOpt.disabled = points.length < 2;
+            emptyEl.style.display = points.length > 0 ? 'none' : 'flex';
+            listEl.innerHTML = '';
+            points.forEach((p, i) => {
+                const li = document.createElement('li');
+                li.className = 'or-li';
+                li.innerHTML = `<span class="or-li-num">${i+1}</span><span class="or-li-name">${p.name}</span><button class="or-li-del" data-id="${p.id}">&times;</button>`;
+                li.querySelector('.or-li-del').onclick = () => manager.deletePoint(p.id);
+                listEl.appendChild(li);
+            });
+        });
+    }
+
+    function setupRouteManager() {
+        if (!window.L) return;
+        const manager = new SimpleRouteManager(window.L);
+        manager.initMap('or-map');
+        const btnOpt = document.getElementById('or-optimize-btn');
+        const listEl = document.getElementById('or-points-list');
+        const emptyEl = document.getElementById('or-empty-state');
+        setupUpdateListener(manager, btnOpt, listEl, emptyEl);
+        manager.addEventListener('loading', e => {
+            btnOpt.classList.toggle('loading', e.detail);
+            btnOpt.querySelector('span').textContent = e.detail ? ui.labels.loading : ui.sidebar.optimizeBtn;
+        });
+        btnOpt.onclick = () => manager.optimize();
+        document.getElementById('or-clear-btn').onclick = () => {
+            manager.points.forEach(p => manager.map.removeLayer(p.marker));
+            manager.points = [];
+            if (manager.routeLine) manager.map.removeLayer(manager.routeLine);
+            document.getElementById('or-stats-panel').classList.add('hidden');
+            manager.notify();
+        };
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', setupRouteManager);
+    } else {
+        setupRouteManager();
+    }
+</script>
+
+<style>
+.optimal-routes {
+    --or-primary: #0891b2;
+    --or-bg: #f8fafc;
+    --or-sidebar-bg: #fff;
+    --or-text: #1e293b;
+    --or-border: #e2e8f0;
+    --or-accent: #06b6d4;
+}
+
+:global(.theme-dark) .optimal-routes {
+    --or-bg: #0f172a;
+    --or-sidebar-bg: #1e293b;
+    --or-text: #f1f5f9;
+    --or-border: #334155;
+}
+
+.or-container {
+    display: flex;
+    height: 100%;
+}
+
+.or-sidebar {
+    width: 320px;
+    background: var(--or-sidebar-bg);
+    border-right: 1px solid var(--or-border);
+    display: flex;
+    flex-direction: column;
+}
+
+.or-sidebar-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--or-border);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.or-sidebar-header h3 {
+    margin: 0;
+    font-size: 1.25rem;
+    font-weight: 800;
+    color: var(--or-text);
+}
+
+.or-btn-clear {
+    background: transparent;
+    border: none;
+    color: #ef4444;
+    cursor: pointer;
+    font-size: 1.2rem;
+    padding: 0.5rem;
+    border-radius: 0.5rem;
+}
+.or-btn-clear:hover {
+    background: #fee2e2;
+}
+
+.or-points-container {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.or-instructions {
+    font-size: 0.75rem;
+    color: #64748b;
+    margin: 0;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-weight: 700;
+}
+
+.or-empty {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    gap: 1rem;
+    color: #94a3b8;
+}
+.or-empty svg {
+    font-size: 3rem;
+    opacity: 0.5;
+}
+
+.or-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.or-li {
+    background: var(--or-bg);
+    border: 1px solid var(--or-border);
+    padding: 0.75rem;
+    border-radius: 0.75rem;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    font-size: 0.85rem;
+    transition: 0.2s;
+}
+.or-li-num {
+    width: 24px;
+    height: 24px;
+    background: var(--or-accent);
+    color: white;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: 800;
+    font-size: 0.7rem;
+}
+.or-li-name {
+    flex: 1;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.or-li-del {
+    background: transparent;
+    border: none;
+    font-size: 1.2rem;
+    color: #94a3b8;
+    cursor: pointer;
+}
+.or-li-del:hover {
+    color: #ef4444;
+}
+
+.or-stats {
+    padding: 1rem;
+    background: #ecfeff;
+    border-top: 1px solid #cffafe;
+}
+:global(.theme-dark) .or-stats {
+    background: #083344;
+    border-top-color: #164e63;
+}
+.or-stat-item {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.85rem;
+}
+
+.or-sidebar-footer {
+    padding: 1rem;
+    border-top: 1px solid var(--or-border);
+}
+
+.or-btn-primary {
+    width: 100%;
+    padding: 1rem;
+    background: var(--or-text);
+    color: var(--or-sidebar-bg);
+    border: none;
+    border-radius: 1rem;
+    font-weight: 800;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+}
+:global(.theme-dark) .or-btn-primary {
+    background: white;
+    color: black;
+}
+.or-btn-primary[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.or-map-wrapper {
+    flex: 1;
+    position: relative;
+}
+.or-map-el {
+    width: 100%;
+    height: 100%;
+    z-index: 10;
+}
+
+.or-map-loader {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 1rem;
+    background: var(--or-bg);
+    z-index: 20;
+    color: var(--or-text);
+}
+
+.hidden { display: none; }
+
+:global(.or-marker-icon) {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+:global(.or-marker-num) {
+    width: 30px;
+    height: 30px;
+    background: #0891b2;
+    color: white;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: 900;
+    border: 3px solid white;
+    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.3);
+}
+
+@media (max-width: 768px) {
+    .or-container {
+        flex-direction: column;
+    }
+    .or-sidebar {
+        width: 100%;
+        height: 300px;
+        order: 2;
+    }
+    .or-map-wrapper {
+        height: 300px;
+        order: 1;
+    }
+}
+</style>

package/src/tool/optimal-routes/i18n/en.ts

@@ -0,0 +1,42 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { OptimalRoutesUI } from '../index';
+
+export const content: ToolLocaleContent<OptimalRoutesUI> = {
+  slug: 'optimal-route-calculator',
+  title: 'Optimal Route Calculator | Smart Stop Reordering',
+  description: 'Optimize your delivery or travel routes for free. Our tool reorders your stops automatically to find the shortest and most efficient path.',
+  ui: {
+    title: "Optimal Routes",
+    sidebar: {
+      title: "Route Plan",
+      addPoint: "Add stop (click map)",
+      pointsList: "Your stops",
+      emptyState: "Click on the map to add stops to your route.",
+      optimizeBtn: "Optimize Sequence",
+      clearBtn: "Clear All",
+      stats: {
+        distance: "Total distance:",
+        time: "Est. time:"
+      }
+    },
+    map: {
+      placeholder: "Loading map...",
+      attribution: "© OpenStreetMap contributors"
+    },
+    errors: {
+      minPoints: "At least two points are needed to calculate a route.",
+      calcError: "Error calculating the optimal route. Please try again."
+    },
+    labels: {
+      origin: "Start",
+      destination: "End",
+      stop: "Stop",
+      loading: "Calculating..."
+    }
+  },
+  seo: [],
+  faq: [],
+  howTo: [],
+  bibliography: [],
+  schemas: []
+};

package/src/tool/optimal-routes/i18n/es.ts

@@ -0,0 +1,52 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { OptimalRoutesUI } from '../index';
+
+export const content: ToolLocaleContent<OptimalRoutesUI> = {
+  slug: 'calculadora-rutas-optimas',
+  title: 'Calculadora de Rutas Óptimas Gratis | Reordena Paradas Inteligente',
+  description: 'Optimiza tus rutas de reparto o viaje gratis. Nuestra herramienta reordena tus paradas automáticamente para encontrar el camino más corto y eficiente.',
+  ui: {
+    title: "Rutas Óptimas",
+    sidebar: {
+      title: "Plan de Ruta",
+      addPoint: "Añadir parada (clic en mapa)",
+      pointsList: "Tus paradas",
+      emptyState: "Haz clic en el mapa para añadir paradas a tu ruta.",
+      optimizeBtn: "Optimizar Secuencia",
+      clearBtn: "Borrar Todo",
+      stats: {
+        distance: "Distancia total:",
+        time: "Tiempo estimado:"
+      }
+    },
+    map: {
+      placeholder: "Mapa cargando...",
+      attribution: "© OpenStreetMap contributors"
+    },
+    errors: {
+      minPoints: "Se necesitan al menos dos puntos para calcular una ruta.",
+      calcError: "Error al calcular la ruta óptima. Inténtalo de nuevo."
+    },
+    labels: {
+      origin: "Inicio",
+      destination: "Fin",
+      stop: "Parada",
+      loading: "Calculando..."
+    }
+  },
+  seo: [
+    { type: "title", text: "Optimización de Rutas Inteligente", level: 2 },
+    { type: "paragraph", html: "Utiliza algoritmos avanzados para resolver el Problema del Viajante (TSP) en segundos. Ideal para logística, repartos o simplemente para ahorrar combustible en tus vacaciones." }
+  ],
+  faq: [
+    { question: "¿Cómo funciona la optimización?", answer: "Analizamos todas tus paradas y determinamos el orden secuencial que minimiza la distancia total recorrida." },
+    { question: "¿Puedo usarlo en el móvil?", answer: "Sí, la herramienta es totalmente responsiva y permite abrir la ruta resultante directamente en Google Maps." }
+  ],
+  howTo: [
+    { name: "Añadir", text: "Haz clic en el mapa para fijar tu posición de inicio y las paradas intermedias." },
+    { name: "Optimizar", text: "Pulsa el botón de optimizar para que el sistema reordene las paradas de la forma más eficiente." },
+    { name: "Navegar", text: "Usa el enlace generado para navegar siguiendo la ruta sugerida." }
+  ],
+  bibliography: [],
+  schemas: []
+};

package/src/tool/optimal-routes/index.ts

@@ -0,0 +1,63 @@
+import type { TravelToolEntry, ToolDefinition } from '../../types';
+import OptimalRoutes from './component.astro';
+import OptimalRoutesSEO from './seo.astro';
+import OptimalRoutesBibliography from './bibliography.astro';
+
+export interface RoutePoint {
+  id: number;
+  lat: number;
+  lng: number;
+  name: string;
+  address?: string;
+}
+
+export interface OptimalRoutesUI {
+  title: string;
+  sidebar: {
+    title: string;
+    addPoint: string;
+    pointsList: string;
+    emptyState: string;
+    optimizeBtn: string;
+    clearBtn: string;
+    stats: {
+      distance: string;
+      time: string;
+    };
+  };
+  map: {
+    placeholder: string;
+    attribution: string;
+  };
+  errors: {
+    minPoints: string;
+    calcError: string;
+  };
+  labels: {
+    origin: string;
+    destination: string;
+    stop: string;
+    loading: string;
+  }
+}
+
+export const optimalRoutes: TravelToolEntry<OptimalRoutesUI> = {
+  id: 'optimal-routes',
+  icons: {
+    bg: 'mdi:map-marker-path',
+    fg: 'mdi:navigation-variant',
+  },
+  i18n: {
+    es: () => import('./i18n/es').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+  },
+};
+
+export { OptimalRoutes, OptimalRoutesSEO, OptimalRoutesBibliography };
+
+export const OPTIMAL_ROUTES_TOOL: ToolDefinition = {
+  entry: optimalRoutes,
+  Component: OptimalRoutes,
+  SEOComponent: OptimalRoutesSEO,
+  BibliographyComponent: OptimalRoutesBibliography,
+};