@jjlmoya/landings 0.4.0

package/src/tests/slug_language_code_format.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+
+describe('Slug language code format validation', () => {
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        describe(`Landing: ${landing.entry.id}`, () => {
+            it('slug should not end with 2-letter language codes like -ja, -ru, -ko', async () => {
+                for (const [locale, loader] of Object.entries(landing.entry.i18n)) {
+                    if (!loader) continue;
+                    const content = await loader();
+
+                    expect(
+                        content.slug,
+                        `Landing "${landing.entry.id}" locale "${locale}" slug ("${content.slug}") cannot end with a 2-letter language code (e.g., -ja, -ru, -ko).`,
+                    ).not.toMatch(/-[a-z]{2}$/);
+                }
+            });
+        });
+    });
+});

package/src/tests/slug_uniqueness.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_LANDING_DEFINITIONS } from '../entries';
+import type { LandingCardContent } from '../types';
+
+const sharingLocales = ['ja', 'ko', 'zh'];
+
+interface ValidateParams {
+    landingId: string;
+    locale: string;
+    content: LandingCardContent;
+    enSlug: string;
+    slugs: Map<string, string>;
+}
+
+const validateLocaleSlug = ({
+    landingId,
+    locale,
+    content,
+    enSlug,
+    slugs,
+}: ValidateParams) => {
+    expect(
+        content.slug,
+        `Landing "${landingId}" 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,
+            `Landing "${landingId}" locale "${locale}" must use the same slug as "en" ("${enSlug}").`,
+        ).toBe(enSlug);
+    } else {
+        expect(
+            content.slug,
+            `Landing "${landingId}" locale "${locale}" has the same slug as "en" ("${enSlug}"). Cada slug tiene que estar en su propio idioma`,
+        ).not.toBe(enSlug);
+
+        if (slugs.has(content.slug)) {
+            const previousLocale = slugs.get(content.slug);
+            expect(
+                false,
+                `Landing "${landingId}" locales "${locale}" and "${previousLocale}" share the same slug ("${content.slug}"). Cada slug tiene que estar en su propio idioma`,
+            ).toBe(true);
+        }
+        slugs.set(content.slug, locale);
+    }
+};
+
+describe('Slug localization and uniqueness validation', () => {
+    ALL_LANDING_DEFINITIONS.forEach((landing) => {
+        describe(`Landing: ${landing.entry.id}`, () => {
+            it('every locale should have a unique, translated slug', async () => {
+                const slugs = new Map<string, string>();
+                const locales = Object.keys(landing.entry.i18n);
+                const enLoader = landing.entry.i18n.en;
+                const enSlug = enLoader ? (await enLoader()).slug : '';
+
+                for (const locale of locales) {
+                    const loader = landing.entry.i18n[locale as keyof typeof landing.entry.i18n];
+                    if (!loader) continue;
+                    validateLocaleSlug({
+                        landingId: landing.entry.id,
+                        locale,
+                        content: await loader(),
+                        enSlug,
+                        slugs,
+                    });
+                }
+            });
+        });
+    });
+});

package/src/tests/title_quality.test.ts

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it } from 'vitest';
+import { getFiles } from './landing-test-helpers';
+
+const srcDir = path.join(process.cwd(), 'src');
+const files = getFiles(path.join(srcDir, 'landing'), ['.ts']).filter((file) => file.includes(`${path.sep}i18n${path.sep}`));
+
+describe('Landing titles - separator validation', () => {
+    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: RegExpExecArray | null;
+            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((finding) => `  - "${finding}"`).join('\n');
+            throw new Error(`Forbidden separators (| or -) found in titles in ${relativePath}:\n${list}`);
+        }
+    });
+});

package/src/types.ts

@@ -0,0 +1,38 @@
+export type KnownLocale =
+    | 'es' | 'en' | 'fr' | 'de' | 'it' | 'pt'
+    | 'nl' | 'sv' | 'pl' | 'id' | 'tr' | 'ru'
+    | 'ja' | 'ko' | 'zh';
+
+export type LocaleLoader<T> = () => Promise<T>;
+export type LocaleMap<T> = Partial<Record<KnownLocale, LocaleLoader<T>>>;
+
+export interface LandingCardContent {
+    slug: string;
+    title: string;
+    subtitle: string;
+    description: string;
+}
+
+export interface LandingPublicAssets {
+    basePath: string;
+    cssPath: string;
+}
+
+export interface LandingSeoMetadata {
+    title: string;
+    description: string;
+    image: string;
+    openGraphImage: string;
+}
+
+export interface LandingEntry {
+    id: string;
+    publicAssets?: LandingPublicAssets;
+    seo?: LandingSeoMetadata;
+    i18n: LocaleMap<LandingCardContent>;
+}
+
+export interface LandingDefinition {
+    entry: LandingEntry;
+    LandingComponent: () => Promise<{ default: unknown }>;
+}