@easy-web/content-blocks 1.0.0

package/src/components/__tests__/UniversalMedia.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import type { ImageMetadata } from 'astro';
+
+/**
+ * Mirrors the dispatch logic inside UniversalMedia.astro.
+ * Tests the categorisation, not the Astro rendering (which requires a full Astro setup).
+ *
+ * The component branches on 4 cases:
+ *   1. ImageMetadata object → <Image> (Astro-optimised)
+ *   2. "/src/assets/..." string → glob lookup → <Image> (with fallback path)
+ *   3. "http(s)://..." string → <Image inferSize>
+ *   4. Everything else (public path) → plain <img>
+ */
+type DispatchCase = 'image-metadata' | 'internal-src-assets' | 'external-url' | 'public-path';
+
+function classifySource(src: ImageMetadata | string): DispatchCase {
+  if (typeof src !== 'string') return 'image-metadata';
+  if (src.startsWith('/src/assets/')) return 'internal-src-assets';
+  if (src.startsWith('http://') || src.startsWith('https://')) return 'external-url';
+  return 'public-path';
+}
+
+// Minimal ImageMetadata stub for test case 1
+const mockImageMetadata: ImageMetadata = {
+  src: '/src/assets/images/test.png',
+  width: 100,
+  height: 100,
+  format: 'png',
+};
+
+describe('<UniversalMedia> dispatch logic', () => {
+  it('case 1: ImageMetadata object → image-metadata', () => {
+    expect(classifySource(mockImageMetadata)).toBe('image-metadata');
+  });
+
+  it('case 2: /src/assets/ string → internal-src-assets (glob lookup path)', () => {
+    expect(classifySource('/src/assets/images/photo.jpg')).toBe('internal-src-assets');
+  });
+
+  it('case 3: https:// URL → external-url (inferSize path)', () => {
+    expect(classifySource('https://example.com/photo.jpg')).toBe('external-url');
+  });
+
+  it('case 4: public path /foo/bar.png → public-path (plain img)', () => {
+    expect(classifySource('/uploads/photo.jpg')).toBe('public-path');
+  });
+
+  it('case 5: glob miss + fallbackSrc → fallback branch applies when resolvedSrc is null', () => {
+    // Simulate glob miss: empty images map for a /src/assets/ URL
+    const images: Record<string, () => Promise<{ default: ImageMetadata }>> = {};
+    const src = '/src/assets/images/missing.png';
+    const fallbackSrc = '/src/assets/images/default.png';
+
+    const dispatch = classifySource(src);
+    expect(dispatch).toBe('internal-src-assets');
+
+    // Verify fallback key lookup works
+    const hasMainImage = src in images;
+    const hasFallback = fallbackSrc in images;
+    expect(hasMainImage).toBe(false); // glob miss
+    expect(hasFallback).toBe(false); // fallback also missing → plain img fallback
+
+    // The component would render plain <img> when both are missing (documented in UniversalMedia)
+  });
+});

package/src/schemas/__tests__/notFound.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { notFoundSchema } from '../notFound.js';
+
+describe('notFoundSchema', () => {
+  it('parses a multi-locale object with partial fields', () => {
+    const input = {
+      de: { heading: 'Seite nicht gefunden', message: 'Existiert nicht.' },
+      en: { heading: 'Not found' },
+    };
+    expect(() => notFoundSchema.parse(input)).not.toThrow();
+    const result = notFoundSchema.parse(input);
+    expect(result.de.heading).toBe('Seite nicht gefunden');
+    expect(result.en.heading).toBe('Not found');
+  });
+
+  it('parses an empty object (all fields optional)', () => {
+    expect(() => notFoundSchema.parse({})).not.toThrow();
+    expect(notFoundSchema.parse({})).toEqual({});
+  });
+
+  it('parses arbitrary locale keys (open record)', () => {
+    const input = { de: {}, fr: {}, sq: {} };
+    expect(() => notFoundSchema.parse(input)).not.toThrow();
+    const result = notFoundSchema.parse(input);
+    expect(Object.keys(result)).toEqual(expect.arrayContaining(['de', 'fr', 'sq']));
+  });
+
+  it('rejects a record where image is not a string', () => {
+    const input = { de: { image: 42 } };
+    expect(() => notFoundSchema.parse(input)).toThrow();
+  });
+});

package/src/schemas/galleries.ts

@@ -0,0 +1,152 @@
+/**
+ * Gallery content collection schema — discriminated union over supported variants.
+ *
+ * Each entry under a consuming site's `src/content/galleries/` selects a `kind`
+ * that determines which Astro component renders it. Pages decide which entry
+ * to load and where to place it; the entry decides what to show and how it is
+ * laid out.
+ *
+ * Supported kinds: `image-grid`, `hero-slider`, `carousel`, `masonry-grid`,
+ * `feature-highlight`, `lightbox-grid`. Adding a new kind requires updating
+ * this union AND adding the matching component in `../components/`. Authoring
+ * an unsupported `kind` fails Zod validation at build time.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { defineCollection } from 'astro:content';
+ * import { glob } from 'astro/loaders';
+ * import { gallerySchema } from '@easy-web/content-blocks/schemas/galleries';
+ *
+ * const galleries = defineCollection({
+ *   loader: glob({ pattern: '**\/*.{yml,yaml}', base: './src/content/galleries' }),
+ *   schema: gallerySchema,
+ * });
+ * ```
+ */
+import { z } from 'zod';
+
+const galleryImageGridSchema = z.object({
+  kind: z.literal('image-grid'),
+  title: z.string().optional(),
+  locale: z.enum(['de', 'en']),
+  translationKey: z.string(),
+  columns: z.union([z.literal(2), z.literal(3), z.literal(4), z.literal(6)]).default(3),
+  gap: z.enum(['sm', 'md', 'lg']).default('md'),
+  aspectRatio: z.enum(['square', '4/3', '16/9', 'auto']).default('square'),
+  items: z.array(z.object({
+    src: z.string().min(1),
+    alt: z.string(),
+    caption: z.string().optional(),
+    href: z.string().optional(),
+  })).min(1),
+});
+
+const galleryHeroSliderSchema = z.object({
+  kind: z.literal('hero-slider'),
+  title: z.string().optional(),
+  locale: z.enum(['de', 'en']),
+  translationKey: z.string(),
+  autoplay: z.boolean().default(true),
+  interval: z.number().int().positive().default(5000),
+  height: z.enum(['sm', 'md', 'lg', 'full']).default('lg'),
+  slides: z.array(z.object({
+    src: z.string().min(1),
+    alt: z.string(),
+    title: z.string(),
+    subtitle: z.string().optional(),
+    href: z.string().optional(),
+    cta: z.string().optional(),
+  })).min(1),
+});
+
+const galleryCarouselSchema = z.object({
+  kind: z.literal('carousel'),
+  title: z.string().optional(),
+  locale: z.enum(['de', 'en']),
+  translationKey: z.string(),
+  autoplay: z.boolean().default(false),
+  interval: z.number().int().positive().default(4000),
+  showDots: z.boolean().default(true),
+  showArrows: z.boolean().default(true),
+  slides: z.array(z.object({
+    src: z.string().min(1),
+    alt: z.string(),
+    caption: z.string().optional(),
+  })).min(1),
+});
+
+const galleryMasonryGridSchema = z.object({
+  kind: z.literal('masonry-grid'),
+  title: z.string().optional(),
+  locale: z.enum(['de', 'en']),
+  translationKey: z.string(),
+  columns: z.union([z.literal(2), z.literal(3), z.literal(4)]).default(3),
+  gap: z.enum(['sm', 'md', 'lg']).default('md'),
+  items: z.array(z.object({
+    src: z.string().min(1),
+    alt: z.string(),
+    caption: z.string().optional(),
+    href: z.string().optional(),
+  })).min(1),
+});
+
+const galleryFeatureHighlightSchema = z.object({
+  kind: z.literal('feature-highlight'),
+  title: z.string().optional(),
+  locale: z.enum(['de', 'en']),
+  translationKey: z.string(),
+  gap: z.enum(['sm', 'md', 'lg']).default('lg'),
+  items: z.array(z.object({
+    src: z.string().min(1),
+    alt: z.string(),
+    title: z.string(),
+    description: z.string(),
+    href: z.string().optional(),
+    cta: z.string().optional(),
+    imagePosition: z.enum(['left', 'right']).optional(),
+  })).min(1),
+});
+
+const galleryLightboxGridSchema = z.object({
+  kind: z.literal('lightbox-grid'),
+  title: z.string().optional(),
+  locale: z.enum(['de', 'en']),
+  translationKey: z.string(),
+  columns: z.union([z.literal(2), z.literal(3), z.literal(4)]).default(3),
+  gap: z.enum(['sm', 'md', 'lg']).default('md'),
+  aspectRatio: z.enum(['square', '4/3', 'auto']).default('square'),
+  items: z.array(z.object({
+    src: z.string().min(1),
+    alt: z.string(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+  })).min(1),
+});
+
+export const gallerySchema = z.discriminatedUnion('kind', [
+  galleryImageGridSchema,
+  galleryHeroSliderSchema,
+  galleryCarouselSchema,
+  galleryMasonryGridSchema,
+  galleryFeatureHighlightSchema,
+  galleryLightboxGridSchema,
+]);
+
+export type GalleryEntry = z.infer<typeof gallerySchema>;
+export type GalleryImageGridData = z.infer<typeof galleryImageGridSchema>;
+export type GalleryHeroSliderData = z.infer<typeof galleryHeroSliderSchema>;
+export type GalleryCarouselData = z.infer<typeof galleryCarouselSchema>;
+export type GalleryMasonryGridData = z.infer<typeof galleryMasonryGridSchema>;
+export type GalleryFeatureHighlightData = z.infer<typeof galleryFeatureHighlightSchema>;
+export type GalleryLightboxGridData = z.infer<typeof galleryLightboxGridSchema>;
+
+export const GALLERY_KINDS = [
+  'image-grid',
+  'hero-slider',
+  'carousel',
+  'masonry-grid',
+  'feature-highlight',
+  'lightbox-grid',
+] as const;
+export type GalleryKind = typeof GALLERY_KINDS[number];

package/src/schemas/notFound.ts

@@ -0,0 +1,33 @@
+/**
+ * Not-found (404) singleton schema — locale-keyed CMS-editable content.
+ *
+ * Each locale key maps to an optional set of fields rendered by the site's
+ * 404 page. All fields are optional so partial translations are valid; a
+ * consuming page falls back to defaults when a field is absent.
+ *
+ * The record key is an open `z.string()` so any IETF locale tag (e.g. `de`,
+ * `en`, `fr`, `sq`, `de-AT`) is accepted without schema changes. Do NOT add
+ * SEO metadata (title, canonical) here — those belong to the page layer.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { notFoundSchema } from '@easy-web/content-blocks/schemas/notFound';
+ *
+ * const data = notFoundSchema.parse(await import('../content/not-found.json'));
+ * ```
+ *
+ * @see docs/decisions/0011-content-architecture-strategy.md
+ * @see docs/decisions/0013-shared-not-found-primitives.md
+ */
+import { z } from 'zod';
+
+export const localizedNotFoundSchema = z.object({
+  image: z.string().optional(),
+  heading: z.string().optional(),
+  message: z.string().optional(),
+});
+
+export const notFoundSchema = z.record(z.string(), localizedNotFoundSchema);
+
+export type NotFoundData = z.infer<typeof notFoundSchema>;