@jjlmoya/utils-home 1.6.0 → 1.8.0

package/package.json

@@ -1,62 +1,63 @@
 {
-  "name": "@jjlmoya/utils-home",
-  "version": "1.6.0",
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
-  "exports": {
-    ".": "./src/index.ts",
-    "./data": "./src/data.ts"
-  },
-  "files": [
-    "src"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "dev": "astro dev",
-    "start": "astro dev",
-    "build": "astro build",
-    "preview": "astro preview",
-    "astro": "astro",
-    "lint": "eslint src/ --max-warnings 0 && stylelint \"src/**/*.{css,astro}\"",
-    "check": "astro check",
-    "type-check": "astro check",
-    "test": "vitest run",
-    "preversion": "npm run lint && npm run test",
-    "postversion": "git push && git push --tags",
-    "patch": "npm version patch",
-    "minor": "npm version minor",
-    "major": "npm version major"
-  },
-  "lint-staged": {
-    "*.{ts,tsx,astro}": [
-      "eslint --fix"
-    ]
-  },
-  "dependencies": {
-    "@iconify-json/mdi": "^1.2.3",
-    "@jjlmoya/utils-shared": "^1.1.0",
-    "astro": "^6.1.2",
-    "astro-icon": "^1.1.0",
-    "qrcode": "^1.5.4"
-  },
-  "devDependencies": {
-    "@astrojs/check": "^0.9.8",
-    "@types/qrcode": "^1.5.6",
-    "eslint": "^9.39.4",
-    "eslint-plugin-astro": "^1.6.0",
-    "eslint-plugin-no-comments": "^1.1.10",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.4.0",
-    "postcss-html": "^1.8.1",
-    "schema-dts": "^1.1.2",
-    "stylelint": "^17.6.0",
-    "stylelint-config-standard": "^40.0.0",
-    "stylelint-declaration-strict-value": "^1.11.1",
-    "typescript": "^5.4.0",
-    "typescript-eslint": "^8.58.0",
-    "vitest": "^4.1.2"
-  }
+    "name": "@jjlmoya/utils-home",
+    "version": "1.8.0",
+    "type": "module",
+    "main": "./src/index.ts",
+    "types": "./src/index.ts",
+    "exports": {
+        ".": "./src/index.ts",
+        "./data": "./src/data.ts"
+    },
+    "files": [
+        "src"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "dev": "astro dev",
+        "start": "astro dev",
+        "build": "astro build",
+        "preview": "astro preview",
+        "astro": "astro",
+        "lint": "eslint src/ --max-warnings 0 && stylelint \"src/**/*.{css,astro}\"",
+        "check": "astro check",
+        "type-check": "astro check",
+        "test": "vitest run",
+        "preversion": "npm run lint && npm run test",
+        "postversion": "git push && git push --tags",
+        "patch": "npm version patch",
+        "minor": "npm version minor",
+        "major": "npm version major"
+    },
+    "lint-staged": {
+        "*.{ts,tsx,astro}": [
+            "eslint --fix"
+        ]
+    },
+    "dependencies": {
+        "@iconify-json/mdi": "^1.2.3",
+        "@jjlmoya/prompagate": "^1.1.0",
+        "@jjlmoya/utils-shared": "1.2.0",
+        "astro": "^6.1.2",
+        "astro-icon": "^1.1.0",
+        "qrcode": "^1.5.4"
+    },
+    "devDependencies": {
+        "@astrojs/check": "^0.9.8",
+        "@types/qrcode": "^1.5.6",
+        "eslint": "^9.39.4",
+        "eslint-plugin-astro": "^1.6.0",
+        "eslint-plugin-no-comments": "^1.1.10",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.4.0",
+        "postcss-html": "^1.8.1",
+        "schema-dts": "^1.1.2",
+        "stylelint": "^17.6.0",
+        "stylelint-config-standard": "^40.0.0",
+        "stylelint-declaration-strict-value": "^1.11.1",
+        "typescript": "^5.4.0",
+        "typescript-eslint": "^8.58.0",
+        "vitest": "^4.1.2"
+    }
 }

package/src/tests/i18n_coverage.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const EXPECTED_LOCALES = [
+  'de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh'
+];
+
+describe('I18n Coverage Validation', () => {
+  it('all tools should be registered', () => {
+    expect(ALL_TOOLS.length).toBeGreaterThan(0);
+  });
+
+  ALL_TOOLS.forEach(({ entry }: { entry: any }) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('should have all 15 required locales', () => {
+        const registeredLocales = Object.keys(entry.i18n);
+        EXPECTED_LOCALES.forEach((locale) => {
+          expect(
+            registeredLocales,
+            `Tool "${entry.id}" is missing locale "${locale}"`,
+          ).toContain(locale);
+        });
+      });
+
+      it('all locale loaders should be functions', () => {
+        EXPECTED_LOCALES.forEach((locale) => {
+          const loader = entry.i18n[locale as keyof typeof entry.i18n];
+          expect(
+            typeof loader,
+            `Tool "${entry.id}" locale "${locale}" loader is not a function`,
+          ).toBe('function');
+        });
+      });
+    });
+  });
+});

package/src/tests/schemas_fulfillment.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('Schemas Fulfillment Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(tool.entry.i18n).forEach((locale) => {
+        it(`Locale: ${locale} should have faqSchema, appSchema and howToSchema`, async () => {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          if (!loader) return;
+          const content = (await loader()) as ToolLocaleContent;
+
+          const schemaTypes = content.schemas.map((s: any) => s['@type']);
+
+          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing FAQPage schema`).toContain('FAQPage');
+          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing SoftwareApplication schema`).toContain('SoftwareApplication');
+          expect(schemaTypes, `Tool "${tool.entry.id}" locale "${locale}" is missing HowTo schema`).toContain('HowTo');
+        });
+      });
+    });
+  });
+});

package/src/tests/slug_language_code_format.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('Slug Language Code Format Validation', () => {
+  const languageCodes = ['de', 'en', 'es', 'fr', 'id', 'it', 'ja', 'ko', 'nl', 'pl', 'pt', 'ru', 'sv', 'tr', 'zh'];
+
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      it('slug should not end with 2-letter language codes like -ja, -ru, -ko', async () => {
+        const locales = Object.keys(tool.entry.i18n);
+
+        for (const locale of locales) {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          const content = (await loader?.()) as ToolLocaleContent;
+
+          const endsWithLanguageCode = languageCodes.some(code => content.slug.endsWith(`-${code}`));
+
+          expect(
+            endsWithLanguageCode,
+            `Tool "${tool.entry.id}" locale "${locale}" slug ("${content.slug}") cannot end with a language code like -ja, -ru, -ko, -de, etc.`,
+          ).toBe(false);
+        }
+      });
+    });
+  });
+});

package/src/tests/slug_uniqueness.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+const sharingLocales = ['ja', 'ko', 'zh'];
+
+interface ValidateParams {
+  toolId: string;
+  locale: string;
+  content: ToolLocaleContent;
+  enSlug: string;
+  slugs: Map<string, string>;
+}
+
+const validateLocaleSlug = ({
+  toolId,
+  locale,
+  content,
+  enSlug,
+  slugs,
+}: ValidateParams) => {
+  expect(
+    content.slug,
+    `Tool "${toolId}" locale "${locale}" has an invalid slug ("${content.slug}"). Slugs must be transliterated (only a-z, 0-9, and -).`,
+  ).toMatch(/^[a-z0-9-]+$/);
+
+  if (locale === 'en') {
+    return;
+  }
+
+  if (sharingLocales.includes(locale)) {
+    expect(
+      content.slug,
+      `Tool "${toolId}" locale "${locale}" must use the same slug as "en" ("${enSlug}").`,
+    ).toBe(enSlug);
+  } else {
+    expect(
+      content.slug,
+      `Tool "${toolId}" locale "${locale}" has the same slug as "en" ("${enSlug}"). Cada slug tiene que estar en su propia idioma`,
+    ).not.toBe(enSlug);
+
+    if (slugs.has(content.slug)) {
+      const previousLocale = slugs.get(content.slug);
+      expect(
+        false,
+        `Tool "${toolId}" locales "${locale}" and "${previousLocale}" share the same slug ("${content.slug}"). Cada slug tiene que estar en su propia idioma`,
+      ).toBe(true);
+    }
+    slugs.set(content.slug, locale);
+  }
+};
+
+describe('Slug Localization and Uniqueness Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      it('every locale should have a unique, translated slug', async () => {
+        const slugs = new Map<string, string>();
+        const locales = Object.keys(tool.entry.i18n);
+
+        let enSlug = '';
+        if (locales.includes('en')) {
+          const enLoader = tool.entry.i18n['en' as keyof typeof tool.entry.i18n];
+          const enContent = (await enLoader?.()) as ToolLocaleContent;
+          enSlug = enContent.slug;
+        }
+
+        for (const locale of locales) {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          const content = (await loader?.()) as ToolLocaleContent;
+          validateLocaleSlug({
+            toolId: tool.entry.id,
+            locale,
+            content,
+            enSlug,
+            slugs,
+          });
+        }
+      });
+    });
+  });
+});

package/src/tests/title_quality.test.ts

@@ -0,0 +1,55 @@
+import { describe, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getFiles(dir: string, ext: string[]): string[] {
+  const results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+  const list = fs.readdirSync(dir);
+  for (const file of list) {
+    const fullPath = path.join(dir, file);
+    const stat = fs.statSync(fullPath);
+    if (stat && stat.isDirectory()) {
+      results.push(...getFiles(fullPath, ext));
+    } else if (ext.some((e) => file.endsWith(e))) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+const SRC_DIR = path.join(process.cwd(), 'src');
+
+describe('Project Titles - Separator Validation', () => {
+  const files = [
+    ...getFiles(path.join(SRC_DIR, 'tool'), ['.ts']),
+    ...getFiles(path.join(SRC_DIR, 'category'), ['.ts']),
+  ].filter(f => f.includes('i18n'));
+
+  it.each(files)('Verify that titles in %s do not contain | or -', (filePath) => {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const relativePath = path.relative(process.cwd(), filePath);
+
+    const titlePatterns = [
+      /const\s+title\s*=\s*['"]([^'"]+)['"]/g,
+      /title\s*:\s*['"]([^'"]+)['"]/g,
+    ];
+
+    const findings: string[] = [];
+
+    for (const pattern of titlePatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const title = match[1];
+        if (title.includes('|') || title.includes('-')) {
+          findings.push(title);
+        }
+      }
+    }
+
+    if (findings.length > 0) {
+      const list = findings.map((f) => `  - "${f}"`).join('\n');
+      throw new Error(`Forbidden separators (| or -) found in titles in ${relativePath}:\n${list}`);
+    }
+  });
+});

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

@@ -0,0 +1,178 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { DewPointCalculatorUI } from '../ui';
+
+const slug = 'taupunkt-rechner';
+const title = 'Taupunkt Rechner';
+const description = 'Berechnen Sie die Kondensationstemperatur an Ihren Wänden basierend auf Luftfeuchtigkeit und Raumtemperatur. Ein wichtiges Werkzeug zur Vermeidung von Schimmel und zum Schutz der Bausubstanz.';
+
+const faqData = [
+  {
+    question: 'Was genau ist der Taupunkt?',
+    answer: 'Der Taupunkt ist die Temperatur, auf die Luft abgekühlt werden muss, damit der darin enthaltene Wasserdampf zu flüssigem Wasser kondensiert. Je höher die relative Luftfeuchtigkeit ist, desto näher liegt der Taupunkt an der aktuellen Temperatur.',
+  },
+  {
+    question: 'Warum bildet sich Schimmel in den Ecken meiner Wohnung?',
+    answer: 'Ecken sind oft Wärmebrücken, an denen die Wand kälter ist. Wenn die Temperatur dieser Oberfläche unter den Taupunkt fällt, bildet sich flüssiges Wasser (Kondensat). Schimmel benötigt diese konstante Feuchtigkeit zum Wachsen.',
+  },
+  {
+    question: 'Wie kann ich die Luftfeuchtigkeit zu Hause senken?',
+    answer: 'Die effektivste Methode ist regelmäßiges Stoßlüften (besonders nach dem Duschen oder Kochen) und der Einsatz von Luftentfeuchtern. Eine konstante Raumtemperatur hilft ebenfalls, da warme Luft mehr Feuchtigkeit aufnehmen kann, ohne zu kondensieren.',
+  },
+  {
+    question: 'Ist Schimmel durch Kondensation gefährlich?',
+    answer: 'Ja. Schimmel setzt Sporen frei, die Atemwegsprobleme, Allergien und Asthma verursachen können. Das Erkennen des Kondensationsrisikos mit diesem Rechner ist der erste Schritt zu einem gesunden Zuhause.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Temperatur und Feuchtigkeit messen',
+    text: 'Verwenden Sie ein Thermometer und ein Hygrometer, um die aktuellen Werte im Raum zu ermitteln.',
+  },
+  {
+    name: 'Werte eingeben',
+    text: 'Stellen Sie die Temperatur in Grad Celsius und die Luftfeuchtigkeit in Prozent im Rechner ein.',
+  },
+  {
+    name: 'Kritische Temperatur ermitteln',
+    text: 'Das Tool zeigt Ihnen genau an, ab welcher Oberflächentemperatur Wasser zu kondensieren beginnt.',
+  },
+  {
+    name: 'Oberflächen prüfen',
+    text: 'Messen Sie mit einem Infrarot-Thermometer die Temperatur Ihrer Wände. Liegt sie am oder unter dem Taupunkt, müssen Sie lüften oder dämmen.',
+  },
+];
+
+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: title,
+  description,
+  step: howToData.map((step) => ({
+    '@type': 'HowToStep',
+    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: 'de',
+};
+
+export const content: ToolLocaleContent<DewPointCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Häufig gestellte Fragen',
+  faq: faqData,
+  bibliographyTitle: 'Literaturhinweise',
+  bibliography: [
+    {
+      name: 'Magnus-Formel zur Berechnung des Taupunkts',
+      url: 'https://de.wikipedia.org/wiki/Taupunkt',
+    },
+    {
+      name: 'WMO Guide to Meteorological Instruments',
+      url: 'https://community.wmo.int/site/knowledge-hub/programmes-and-initiatives/instruments-and-methods-of-observation-programme-imop/guide-instruments-and-methods-of-observation-wmo-no-8',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Was ist der Taupunkt und warum ist er für Ihr Zuhause wichtig?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Der Taupunkt markiert die Temperatur, bei der Luftfeuchtigkeit zu Wasser wird. In Wohnräumen ist dieser Wert entscheidend für die Vermeidung von Bauschäden. Wenn die Temperatur einer Oberfläche (z. B. einer schlecht gedämmten Außenwand) unter den Taupunkt sinkt, entsteht Kondenswasser – der ideale Nährboden für <em>Aspergillus</em> und andere gesundheitsschädliche Pilze.',
+    },
+    {
+      type: 'stats',
+      items: [
+        { value: '> 5°C', label: 'Sicherer Bereich', icon: 'mdi:shield-check' },
+        { value: '40–60%', label: 'Ideale Feuchte', icon: 'mdi:water-percent' },
+        { value: '< 1°C', label: 'Akute Gefahr', icon: 'mdi:alert' },
+      ],
+      columns: 3,
+    },
+    {
+      type: 'comparative',
+      items: [
+        {
+          title: 'Magnus Tetens Formel',
+          description: 'Zur präzisen Berechnung nutzen wir die Magnus-Tetens-Näherung. Diese Formel wird von der Weltorganisation für Meteorologie (WMO) für Temperaturen zwischen 0°C und 50°C empfohlen.',
+          icon: 'mdi:calculator',
+          points: ['Wissenschaftlich validierte Präzision', 'Optimiert für Wohnraumtemperaturen'],
+        },
+        {
+          title: 'Wärmebrücken und Schimmel',
+          description: 'Ecken, Fensterrahmen und ungenügend gedämmte Wände sind die kältesten Stellen im Haus. Sinkt dort die Temperatur unter den Taupunkt, ist Schimmelbildung vorprogrammiert.',
+          icon: 'mdi:home-thermometer',
+          points: ['Ecken sind besonders anfällig', 'Wärmedämmung verhindert Kondensation'],
+        },
+      ],
+      columns: 2,
+    },
+    {
+      type: 'title',
+      text: 'Risikostufen',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: '<strong>Geringes Risiko (Diff. &gt; 5°C):</strong> Die Wände sind sicher. <strong>Mittleres Risiko (3–5°C):</strong> Achten Sie auf Ecken und Wärmebrücken. <strong>Hohes Risiko (1–3°C):</strong> Kondensation an Scheiben wahrscheinlich – sofort lüften. <strong>Akute Gefahr (&lt; 1°C):</strong> Aktive Kondensation mit sofortigem Risiko für schwarzen Schimmel.',
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Die goldene Regel',
+      icon: 'mdi:thermometer-alert',
+      badge: 'Experten-Tipp',
+      html: '<p>Wenn die Wandtemperatur weniger als <strong>3°C über dem Taupunkt</strong> liegt, besteht unmittelbare Kondensationsgefahr. Lüften Sie regelmäßig und halten Sie die Luftfeuchtigkeit zwischen 40 % und 60 %.</p>',
+    },
+    {
+      type: 'summary',
+      title: 'So vermeiden Sie Kondenswasser',
+      items: [
+        'Täglich mehrmals stoßlüften, besonders nach dem Duschen oder Kochen.',
+        'Relative Luftfeuchtigkeit zwischen 40 % und 60 % halten.',
+        'Dunstabzugshauben in der Küche konsequent nutzen.',
+        'Wäsche nicht in der Wohnung trocknen (oder nur bei guter Belüftung).',
+        'Außenwände dämmen, um kalte Oberflächen zu vermeiden.',
+      ],
+    },
+  ],
+  ui: {
+    labelTemperature: 'Raumtemperatur',
+    labelHumidity: 'Rel. Luftfeuchtigkeit',
+    labelDewPoint: 'Taupunkt',
+    riskLow: 'Geringes Risiko',
+    riskMedium: 'Mittleres Risiko',
+    riskHigh: 'Hohes Risiko',
+    riskExtreme: 'Akute Gefahr',
+    riskLowDesc: 'Differenz > 5°C. Wände sind sicher.',
+    riskMediumDesc: 'Differenz 3–5°C. Ecken prüfen.',
+    riskHighDesc: 'Differenz 1–3°C. Sofort lüften!',
+    riskExtremeDesc: 'Differenz < 1°C. Aktive Kondensation.',
+  },
+};

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

@@ -124,7 +124,7 @@ export const content: ToolLocaleContent<DewPointCalculatorUI> = {
       type: 'comparative',
       items: [
         {
-          title: 'The Magnus-Tetens Formula',
+          title: 'The Magnus Tetens Formula',
           description: 'To calculate the dew point with scientific accuracy we use the Magnus-Tetens approximation, with constants b=17.625 and c=243.04°C recommended by the World Meteorological Organization for temperatures between 0°C and 50°C.',
           icon: 'mdi:calculator',
           points: ['Scientific accuracy validated by the WMO', 'Valid for residential temperature ranges'],

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

@@ -124,7 +124,7 @@ export const content: ToolLocaleContent<DewPointCalculatorUI> = {
       type: 'comparative',
       items: [
         {
-          title: 'La Fórmula de Magnus-Tetens',
+          title: 'La Fórmula de Magnus Tetens',
           description: 'Para calcular el punto de rocío con precisión científica utilizamos la aproximación de Magnus-Tetens, con constantes b=17.625 y c=243.04°C recomendadas por la Organización Meteorológica Mundial para temperaturas entre 0°C y 50°C.',
           icon: 'mdi:calculator',
           points: ['Precisión científica validada por la OMM', 'Válida para rangos de temperatura habitacional'],

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

@@ -124,7 +124,7 @@ export const content: ToolLocaleContent<DewPointCalculatorUI> = {
       type: 'comparative',
       items: [
         {
-          title: 'La Formule de Magnus-Tetens',
+          title: 'La Formule de Magnus Tetens',
           description: "Pour calculer le point de rosée avec précision scientifique, nous utilisons l'approximation de Magnus-Tetens, avec les constantes b=17,625 et c=243,04°C recommandées par l'Organisation Météorologique Mondiale pour des températures entre 0°C et 50°C.",
           icon: 'mdi:calculator',
           points: ["Précision scientifique validée par l'OMM", 'Valide pour les plages de température résidentielles'],