@jjlmoya/utils-converters 1.6.0 → 1.8.0

package/package.json

@@ -1,61 +1,62 @@
 {
-  "name": "@jjlmoya/utils-converters",
-  "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",
-    "jszip": "^3.10.1"
-  },
-  "devDependencies": {
-    "@astrojs/check": "^0.9.8",
-    "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-converters",
+    "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",
+        "jszip": "^3.10.1"
+    },
+    "devDependencies": {
+        "@astrojs/check": "^0.9.8",
+        "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/shared/ImageConverter.astro

@@ -352,7 +352,8 @@ const acceptInput = (from || 'jpg') === 'svg' ? '.svg' : 'image/*';
     processSvgToRaster,
   } from './logic/converter';
   import type { ConversionItem, ImageFormat } from './logic/converter';
-  import JSZip from 'jszip';
+  import * as JSZipModule from 'jszip';
+  const JSZip = JSZipModule.default || JSZipModule;
 
   const dropZone = document.getElementById('converter-drop-zone');
   const fileInput = document.getElementById('converter-input') as HTMLInputElement;

package/src/shared/logic/schemas.ts

@@ -0,0 +1,57 @@
+import type { WithContext, SoftwareApplication, FAQPage, HowTo, Thing } from 'schema-dts';
+import type { FAQItem, HowToStep } from '../../types';
+
+interface SchemaOptions {
+  title: string;
+  description: string;
+  inLanguage: string;
+  faq: FAQItem[];
+  howTo: HowToStep[];
+}
+
+function buildAppSchema(title: string, description: string, inLanguage: string): WithContext<SoftwareApplication> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    inLanguage,
+  };
+}
+
+function buildFaqSchema(faq: FAQItem[]): WithContext<FAQPage> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  };
+}
+
+function buildHowToSchema(title: string, howTo: HowToStep[]): WithContext<HowTo> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    step: howTo.map((step) => ({
+      '@type': 'HowToStep',
+      name: step.name,
+      itemListElement: [{ '@type': 'HowToDirection', text: step.text }],
+    })),
+  };
+}
+
+export function generateSchemas(options: SchemaOptions): WithContext<Thing>[] {
+  const { title, description, inLanguage, faq, howTo } = options;
+  return [
+    buildAppSchema(title, description, inLanguage),
+    buildFaqSchema(faq),
+    buildHowToSchema(title, howTo),
+  ] as WithContext<Thing>[];
+}

package/src/tests/faq_count.test.ts

@@ -1,10 +1,19 @@
 import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
+import type * as DATA from '../data';
+
+const TOOLS: typeof DATA.audiovisualCategory[] = [];
 
 describe('FAQ Content Validation', () => {
-  it('all tools have i18n defined', () => {
-    ALL_TOOLS.forEach((tool) => {
-      expect(tool.entry.i18n).toBeDefined();
+  TOOLS.forEach((entry) => {
+    describe(`Tool: ${entry.icon}`, () => {
+      it('placeholder', () => {
+        expect(true).toBe(true);
+      });
     });
   });
+
+  it('no tools registered yet', () => {
+    expect(TOOLS.length).toBe(0);
+  });
 });
+

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/locale_completeness.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('Locale Completeness Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(tool.entry.i18n).forEach((locale) => {
+        describe(`Locale: ${locale}`, () => {
+          it('faqTitle should be defined when faq items exist', async () => {
+            const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+            const content = (await loader?.()) as ToolLocaleContent;
+
+            if (content.faq.length > 0) {
+              expect(
+                content.ui.faqTitle,
+                `Tool "${tool.entry.id}" locale "${locale}" has ${content.faq.length} FAQ items but is missing faqTitle`,
+              ).toBeTruthy();
+            }
+          });
+
+          it('bibliographyTitle should be defined when bibliography items exist', async () => {
+            const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+            const content = (await loader?.()) as ToolLocaleContent;
+
+            if (content.bibliography.length > 0) {
+              expect(
+                content.ui.bibliographyTitle,
+                `Tool "${tool.entry.id}" locale "${locale}" has ${content.bibliography.length} bibliography items but is missing bibliographyTitle`,
+              ).toBeTruthy();
+            }
+          });
+        });
+      });
+    });
+  });
+
+  it('all 21 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(21);
+  });
+});
+

package/src/tests/no_h1_in_components.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const EXCLUDED_DIRS = ['node_modules', 'pages', 'layouts'];
+
+function findAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory() && !EXCLUDED_DIRS.includes(entry.name)) {
+      files.push(...findAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.astro')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function hasH1(content: string): boolean {
+  return /<h1[\s>]/i.test(content);
+}
+
+const srcDir = join(process.cwd(), 'src');
+const astroFiles = findAstroFiles(srcDir);
+
+describe('No H1 in Components', () => {
+  if (astroFiles.length === 0) {
+    it('no astro components found', () => {
+      expect(true).toBe(true);
+    });
+  }
+
+  astroFiles.forEach((file) => {
+    const relativePath = file.replace(process.cwd(), '');
+    it(`${relativePath} should not contain <h1>`, () => {
+      const content = readFileSync(file, 'utf-8');
+      expect(
+        hasH1(content),
+        `File "${relativePath}" contains a <h1> element. Use <h2> or lower inside components — h1 belongs to the page layout.`,
+      ).toBe(false);
+    });
+  });
+});
+

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/seo_length.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import * as DATA from '../data';
 
 const ENTRIES = [

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/avifAJpg/i18n/de.ts

@@ -0,0 +1,178 @@
+import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
+import { generateSchemas } from '../../../shared/logic/schemas';
+import type { AvifAJpgLocaleContent } from '../index';
+
+const slug = 'avif-zu-jpg-konvertieren';
+const title = 'AVIF in JPG Online Konvertieren';
+const description =
+  'Konvertieren Sie AVIF-Bilder in Ihrem Browser in JPG. Ohne Server. 100 % private lokale Verarbeitung. Kostenlos und unbegrenzt.';
+
+const ui: ImageConverterUI = {
+  dragText: 'AVIF-Dateien hierher ziehen...',
+  convertText: 'Um sie sofort in JPG zu konvertieren',
+  selectFiles: 'Dateien auswählen',
+  processedFiles: 'Verarbeitete Dateien',
+  downloadAll: 'Alles herunterladen (.zip)',
+  pending: 'Ausstehend',
+  bibliographyTitle: 'Literaturhinweise',
+  faqTitle: 'Häufig gestellte Fragen',
+};
+
+const faq: AvifAJpgLocaleContent['faq'] = [
+  {
+    question: 'Warum AVIF in JPG konvertieren?',
+    answer:
+      'Das AVIF-Format bietet eine überlegene Kompression, aber nicht alle Programme oder Viewer unterstützen es. Die Konvertierung in JPG stellt sicher, dass das Bild auf 100 % der Geräte weltweit angezeigt werden kann.',
+  },
+  {
+    question: 'Wie schützen wir Ihre AVIF-Bilder?',
+    answer:
+      'Ihre Fotos verlassen niemals Ihr Handy oder Ihren PC. Der gesamte Prozess des Zeichnens und Kodierens in JPEG wird in der JavaScript-Umgebung Ihres Browsers ausgeführt.',
+  },
+  {
+    question: 'Verliere ich bei der Umwandlung von AVIF zu JPG an Qualität?',
+    answer:
+      'Unser Tool verarbeitet die Pixel mit einer Standard-Canvas-Qualität (0,9 bis 0,95), sodass die Änderungen kaum wahrnehmbar sind.',
+  },
+];
+
+const howTo: AvifAJpgLocaleContent['howTo'] = [
+  {
+    name: 'Dateien ziehen oder klicken',
+    text: 'Verschieben Sie alle AVIF-Fotos, die Sie konvertieren möchten, in den markierten Verarbeitungsbereich.',
+  },
+  {
+    name: 'Sofortige Transformation',
+    text: 'Beobachten Sie in weniger als einer Sekunde, wie das AVIF in JPG neu kodiert wird, wobei mögliche Alphakanäle durch einen soliden Hintergrund ersetzt werden.',
+  },
+  {
+    name: 'Speichern oder ZIP herunterladen',
+    text: 'Laden Sie Ihre neuen JPG-Bilder einzeln herunter oder drücken Sie auf "Alles herunterladen", wenn Sie in Stapeln verarbeitet haben.',
+  },
+];
+
+const bibliography: AvifAJpgLocaleContent['bibliography'] = [
+  {
+    name: 'AV1 Image File Format (AVIF)',
+    url: 'https://aomediacodec.github.io/av1-avif/',
+  },
+  {
+    name: 'Allgemeine Informationen zu JPG',
+    url: 'https://en.wikipedia.org/wiki/JPEG',
+  },
+];
+
+const seo: AvifAJpgLocaleContent['seo'] = [
+  {
+    type: 'title',
+    text: 'AVIF-zu-JPG-Konverter: Universelle Kompatibilität für Ihre modernen Bilder',
+    level: 2,
+  },
+  {
+    type: 'paragraph',
+    html: 'AVIF (AV1 Image File Format) ist das effizienteste Bildformat, das heute verfügbar ist. Es wurde von der Alliance for Open Media entwickelt und basiert auf dem AV1-Videocodec. Es bietet eine um 50 % höhere Kompression als JPG bei gleicher visueller Qualität. Dieser technische Vorteil hat jedoch seinen Preis: AVIF wird von Photoshop, Lightroom, dem Windows Photo Viewer und den meisten herkömmlichen Bearbeitungs- und Anzeigetools nicht unterstützt. Das Konvertieren in JPG löst dieses Problem an der Wurzel.',
+  },
+  {
+    type: 'title',
+    text: 'AVIF vs. JPG: Effizienz gegenüber universeller Kompatibilität',
+    level: 3,
+  },
+  {
+    type: 'paragraph',
+    html: 'AVIF komprimiert außergewöhnlich gut: Ein hochauflösendes Foto, das in JPG 4 MB einnimmt, kann in AVIF bei gleicher wahrgenommener Qualität nur 2 MB wiegen. Dies macht es perfekt für die Web-Bereitstellung, bei der die Ladeleistung kritisch ist. Außerhalb des Browsers ist AVIF jedoch praktisch unsichtbar: Weder der Windows Explorer zeigt eine Vorschau an, noch exportieren Kameras es, noch nehmen Designer es gerne in ihre Arbeitsabläufe auf.',
+  },
+  {
+    type: 'paragraph',
+    html: 'JPG ist seit über 30 Jahren der universelle Standard der digitalen Fotografie. Es wird von 100 % der Geräte, Betriebssysteme, Büroanwendungen, sozialen Netzwerke, Drucker und jeder Software unterstützt, die jemals ein Bild gesehen hat. Wenn Sie Bilder teilen, drucken, bearbeiten oder per E-Mail versenden müssen, ist JPG die Garantie dafür, dass alles reibungslos funktioniert.',
+  },
+  {
+    type: 'title',
+    text: 'Vergleich: Cloud-Konverter vs. Unsere lokale Architektur',
+    level: 3,
+  },
+  {
+    type: 'comparative',
+    items: [
+      {
+        title: 'Cloud Konverter',
+        description: 'Tools, die Ihre AVIF-Dateien zur Verarbeitung auf einen Remote-Server hochladen.',
+        icon: 'mdi:cloud-upload',
+        pointIcon: 'mdi:close-circle-outline',
+        points: [
+          'Ihre privaten Fotos reisen über das Internet zu externen Servern',
+          'Wartezeiten durch Hoch- und Herunterladen der Datei',
+          'Größenbeschränkungen und Anzahl der kostenlosen Konvertierungen',
+          'Risiko der Aufbewahrung von Bildern auf Servern von Drittanbietern',
+        ],
+      },
+      {
+        title: 'Unsere lokale Architektur',
+        description: 'Direkte Verarbeitung in Ihrem Browser mittels Vanilla JS-Technologie und Canvas API.',
+        icon: 'mdi:laptop-mac',
+        highlight: true,
+        points: [
+          'Ihre Bilder verlassen niemals Ihr Gerät',
+          'Sofortige Konvertierung ohne Netzwerklatenz',
+          'Keine Beschränkungen für Dateien oder Größe',
+          'Geeignet für medizinische, rechtliche oder vertrauliche Bilder',
+        ],
+      },
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Wie die technische Konvertierung im Browser funktioniert',
+    level: 3,
+  },
+  {
+    type: 'paragraph',
+    html: 'Moderne Browser wie Chrome, Firefox und Edge bieten dank ihrer integrierten AV1-Decoder native Unterstützung für AVIF. Wenn Sie eine AVIF-Datei laden, dekodiert der Browser sie im Speicher und wandelt sie in eine Bitmap-Darstellung im RAM um. Diese Darstellung wird auf ein unsichtbares HTML5-<code>Canvas</code>-Element gezeichnet.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Anschließend exportiert das Canvas das Bild mit <code>toBlob(\'image/jpeg\', quality)</code> unter Anwendung der Standard-JPG-Kompression. Da JPG keine Transparenzen unterstützt, wird jeder im AVIF vorhandene Alphakanal vor dem Export mit einem weißen Hintergrund gefüllt. Das Ergebnis ist eine qualitativ hochwertige JPG-Datei, die zum direkten Download bereitsteht, ohne dass ein Byte Ihren Browser verlassen hat.',
+  },
+  {
+    type: 'tip',
+    title: 'Das perfekte Gleichgewicht zwischen Kompression und Kompatibilität',
+    html: 'AVIF ist bei gleicher Qualität um 50 % kleiner als JPG – aber JPG bietet 100 % Kompatibilität mit jeder Software. Wenn Sie AVIF-Bilder vom Server erhalten und diese bearbeiten, per E-Mail versenden oder in Desktop-Tools öffnen müssen, konvertieren Sie sie zuerst in JPG.',
+  },
+  {
+    type: 'title',
+    text: 'Anwendungsfälle: Wann man AVIF in JPG konvertieren sollte',
+    level: 3,
+  },
+  {
+    type: 'list',
+    icon: 'mdi:check-circle',
+    items: [
+      'Bearbeiten in Photoshop, Lightroom, GIMP oder anderer Desktop-Software.',
+      'Teilen von Bildern mit Benutzern auf alten Geräten oder Betriebssystemen.',
+      'Anhängen an E-Mails, um die Anzeige in jedem E-Mail-Client zu garantieren.',
+      'Veröffentlichen auf Plattformen, die AVIF nicht als Upload-Format akzeptieren.',
+      'Drucken: Professionelle Druckdienste arbeiten nativ mit JPG.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Fazit: Universelle Kompatibilität in einem Schritt',
+    level: 3,
+  },
+  {
+    type: 'paragraph',
+    html: 'AVIF ist die Zukunft der Bildkompression, aber die Gegenwart verlangt Kompatibilität. Unser Konverter ermöglicht es Ihnen, das Beste aus beiden Welten zu erhalten: Empfangen und speichern Sie Bilder in AVIF für maximale Effizienz, und konvertieren Sie sie sofort in JPG, wenn sie in einem beliebigen Kontext funktionieren müssen. Alles privat, kostenlos und unbegrenzt.',
+  },
+];
+
+
+export const content: AvifAJpgLocaleContent = {
+  slug,
+  title,
+  description,
+  ui,
+  seo,
+  faq,
+  bibliography,
+  howTo,
+  schemas: generateSchemas({ title, description, inLanguage: 'de', faq, howTo }),
+};

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

@@ -1,5 +1,5 @@
-import type { WithContext, SoftwareApplication } from 'schema-dts';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
+import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
 
 const slug = 'avif-to-jpg-converter';
@@ -164,16 +164,6 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   },
 ];
 
-const appSchema: WithContext<SoftwareApplication> = {
-  '@context': 'https://schema.org',
-  '@type': 'SoftwareApplication',
-  name: title,
-  description,
-  applicationCategory: 'UtilitiesApplication',
-  operatingSystem: 'Web',
-  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
-  inLanguage: 'en',
-};
 
 export const content: AvifAJpgLocaleContent = {
   slug,
@@ -184,5 +174,5 @@ export const content: AvifAJpgLocaleContent = {
   faq,
   bibliography,
   howTo,
-  schemas: [appSchema as any],
+  schemas: generateSchemas({ title, description, inLanguage: 'en', faq, howTo }),
 };