@warpgogol/werkstatt-shared 0.14.0 → 0.14.1

package/src/share/schemas/tests/section-shell.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import {
+  sectionDensitySchema,
+  sectionToneSchema,
+  sectionContainerVariantSchema,
+  sectionShellAnimatedSchema,
+} from "../section-shell.ts";
+
+describe("sectionDensitySchema", () => {
+  it("accepts valid densities", () => {
+    for (const d of ["compact", "normal", "spacious", "flush"]) {
+      expect(sectionDensitySchema.parse(d)).toBe(d);
+    }
+  });
+
+  it("rejects invalid density", () => {
+    expect(() => sectionDensitySchema.parse("loose")).toThrow();
+  });
+});
+
+describe("sectionToneSchema", () => {
+  it("accepts valid tones", () => {
+    for (const t of ["default", "warning", "success", "muted"]) {
+      expect(sectionToneSchema.parse(t)).toBe(t);
+    }
+  });
+});
+
+describe("sectionContainerVariantSchema", () => {
+  it("accepts valid variants", () => {
+    for (const v of ["default", "narrow", "full"]) {
+      expect(sectionContainerVariantSchema.parse(v)).toBe(v);
+    }
+  });
+});
+
+describe("sectionShellAnimatedSchema", () => {
+  it("accepts valid values", () => {
+    expect(sectionShellAnimatedSchema.parse("none")).toBe("none");
+    expect(sectionShellAnimatedSchema.parse("reveal")).toBe("reveal");
+  });
+});

package/src/share/schemas/tests/section-stats.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from "vitest";
+import { statItemSchema } from "../section-stats.ts";
+
+describe("statItemSchema", () => {
+  it("accepts a valid stat item", () => {
+    const result = statItemSchema.safeParse({
+      label: "Users",
+      value: "10K",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects empty object", () => {
+    const result = statItemSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});

package/src/share/schemas/tests/site-background.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { siteBackgroundLayerSchema } from "../site-background.ts";
+
+describe("siteBackgroundLayerSchema", () => {
+  it("accepts color kind", () => {
+    const result = siteBackgroundLayerSchema.safeParse({ kind: "color" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts image kind with imageName", () => {
+    const result = siteBackgroundLayerSchema.safeParse({
+      kind: "image",
+      imageName: "bg",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts gradient kind with required fields", () => {
+    const result = siteBackgroundLayerSchema.safeParse({
+      kind: "gradient",
+      direction: "vertical",
+      stops: [
+        { at: 0, color: "#000" },
+        { at: 1, color: "#fff" },
+      ],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid kind", () => {
+    expect(() => siteBackgroundLayerSchema.parse({ kind: "video" })).toThrow();
+  });
+});

package/src/share/schemas/tests/standard-list-item.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { standardListItemSchema } from "../standard-list-item.ts";
+
+describe("standardListItemSchema", () => {
+  it("accepts a valid list item", () => {
+    const result = standardListItemSchema.safeParse({
+      text: "Test item",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects empty object", () => {
+    const result = standardListItemSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});

package/src/share/scripts/tests/external-link-qr.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initExternalLinkQr } from "../external-link-qr.ts";
+
+describe("initExternalLinkQr", () => {
+  it("is a function", () => {
+    expect(typeof initExternalLinkQr).toBe("function");
+  });
+});

package/src/share/scripts/tests/external-links.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { applyExternalLinkBehavior } from "../external-links.ts";
+
+describe("applyExternalLinkBehavior", () => {
+  beforeEach(() => {
+    vi.stubGlobal("document", {
+      querySelectorAll: vi.fn(() => []),
+    });
+    vi.stubGlobal("window", {
+      location: { href: "https://example.com/", origin: "https://example.com" },
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("is a function", () => {
+    expect(typeof applyExternalLinkBehavior).toBe("function");
+  });
+
+  it("does not throw when no anchors exist", () => {
+    expect(() => applyExternalLinkBehavior()).not.toThrow();
+  });
+});

package/src/share/scripts/tests/gsap-counter.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initGsapCounter } from "../gsap-counter.ts";
+
+describe("initGsapCounter", () => {
+  it("is an async function", () => {
+    expect(typeof initGsapCounter).toBe("function");
+  });
+});

package/src/share/scripts/tests/gsap-mountain-journey.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initMountainJourneyAnimation } from "../gsap-mountain-journey.ts";
+
+describe("initMountainJourneyAnimation", () => {
+  it("is an async function", () => {
+    expect(typeof initMountainJourneyAnimation).toBe("function");
+  });
+});

package/src/share/scripts/tests/gsap-parallax.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initGsapParallax } from "../gsap-parallax.ts";
+
+describe("initGsapParallax", () => {
+  it("is an async function", () => {
+    expect(typeof initGsapParallax).toBe("function");
+  });
+});

package/src/share/scripts/tests/gsap-reveal.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initGsapReveal } from "../gsap-reveal.ts";
+
+describe("initGsapReveal", () => {
+  it("is an async function", () => {
+    expect(typeof initGsapReveal).toBe("function");
+  });
+});

package/src/share/scripts/tests/gsap-stagger.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initGsapStagger } from "../gsap-stagger.ts";
+
+describe("initGsapStagger", () => {
+  it("is an async function", () => {
+    expect(typeof initGsapStagger).toBe("function");
+  });
+});

package/src/share/scripts/tests/inline-number-animation.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initInlineNumberAnimation } from "../inline-number-animation.ts";
+
+describe("initInlineNumberAnimation", () => {
+  it("is an async function", () => {
+    expect(typeof initInlineNumberAnimation).toBe("function");
+  });
+});

package/src/share/scripts/tests/lenis.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initLenis } from "../lenis.ts";
+
+describe("initLenis", () => {
+  it("is an async function", () => {
+    expect(typeof initLenis).toBe("function");
+  });
+});

package/src/share/scripts/tests/live-photos.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initLivePhotos } from "../live-photos.ts";
+
+describe("initLivePhotos", () => {
+  it("is an async function", () => {
+    expect(typeof initLivePhotos).toBe("function");
+  });
+});

package/src/share/scripts/tests/lordicon.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { initLordIconOnDemand } from "../lordicon.ts";
+
+describe("initLordIconOnDemand", () => {
+  it("is a function", () => {
+    expect(typeof initLordIconOnDemand).toBe("function");
+  });
+});

package/src/share/scripts/tests/orchestrator.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { runStandardLayoutOrchestration } from "../orchestrator.ts";
+
+describe("runStandardLayoutOrchestration", () => {
+  it("is an async function", () => {
+    expect(typeof runStandardLayoutOrchestration).toBe("function");
+  });
+});

package/src/share/scripts/tests/scheduler.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { scheduleTask } from "../scheduler.ts";
+
+describe("scheduleTask", () => {
+  beforeEach(() => {
+    vi.stubGlobal("window", {
+      requestIdleCallback: vi.fn(),
+      setTimeout: vi.fn(),
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("is a function", () => {
+    expect(typeof scheduleTask).toBe("function");
+  });
+
+  it("does not throw when scheduling a task", () => {
+    expect(() => scheduleTask(() => undefined)).not.toThrow();
+  });
+});

package/src/share/semantic/jsonld/tests/article.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { buildArticleNode } from "../article.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildArticleNode", () => {
+  it("returns null when page has no datePublished", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildArticleNode(ctx)).toBeNull();
+  });
+
+  it("builds Article/BlogPosting node with datePublished", () => {
+    const page = makePage({ datePublished: "2024-01-15" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toEqual(["Article", "BlogPosting"]);
+    expect(node!.datePublished).toBe("2024-01-15");
+    expect(node!.dateModified).toBe("2024-01-15");
+    expect(node!.headline).toBe("Test Heading");
+    expect(node!.inLanguage).toBe("de");
+    expect(node!.publisher).toEqual({ "@id": ctx.ids.organization });
+  });
+
+  it("uses dateModified when provided", () => {
+    const page = makePage({ datePublished: "2024-01-15", dateModified: "2024-06-01" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.dateModified).toBe("2024-06-01");
+  });
+
+  it("emits author as Person when author string is present", () => {
+    const page = makePage({ datePublished: "2024-01-15", author: "Jane Doe" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.author).toEqual({ "@type": "Person", name: "Jane Doe" });
+  });
+
+  it("emits structured author from authorRecord", () => {
+    const page = makePage({
+      datePublished: "2024-01-15",
+      authorRecord: { name: "Jane Doe", contactUrl: "https://example.com/contact" },
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.author).toEqual({
+      "@type": "Person",
+      name: "Jane Doe",
+      url: "https://example.com/contact",
+    });
+  });
+
+  it("emits keywords as comma-separated string", () => {
+    const page = makePage({ datePublished: "2024-01-15", keywords: ["foo", "bar"] });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.keywords).toBe("foo, bar");
+  });
+
+  it("emits image from primaryImage", () => {
+    const page = makePage({
+      datePublished: "2024-01-15",
+      primaryImage: { url: "https://example.com/img.jpg" },
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.image).toBe("https://example.com/img.jpg");
+  });
+
+  it("uses page URL as mainEntityOfPage for ratgeber depth-1", () => {
+    const page = makePage({
+      datePublished: "2024-01-15",
+      surfaceId: "ratgeber",
+      depth: 1,
+      url: "https://example.com/de/ratgeber/article/",
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.mainEntityOfPage).toBe("https://example.com/de/ratgeber/article/");
+  });
+
+  it("uses webpage @id as mainEntityOfPage for non-ratgeber pages", () => {
+    const page = makePage({ datePublished: "2024-01-15" });
+    const ctx = createJsonLdContext(page);
+    const node = buildArticleNode(ctx);
+    expect(node!.mainEntityOfPage).toEqual({ "@id": ctx.webpageId });
+  });
+});

package/src/share/semantic/jsonld/tests/breadcrumb.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { buildBreadcrumbNode } from "../breadcrumb.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildBreadcrumbNode", () => {
+  it("returns null when only one breadcrumb", () => {
+    const page = makePage({
+      breadcrumbs: [{ name: "Home", url: "https://example.com/de/" }],
+    });
+    const ctx = createJsonLdContext(page);
+    expect(buildBreadcrumbNode(ctx)).toBeNull();
+  });
+
+  it("builds BreadcrumbList with multiple crumbs", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "About", url: "https://example.com/de/about/" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildBreadcrumbNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("BreadcrumbList");
+    expect(node!.itemListElement).toHaveLength(2);
+    expect(node as Record<string, unknown>).toMatchObject({
+      itemListElement: [
+        { position: 1, name: "Home" },
+        { position: 2, name: "About" },
+      ],
+    });
+  });
+
+  it("resolves relative crumb URLs against page URL", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "/de/" },
+        { name: "About", url: "/de/about/" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildBreadcrumbNode(ctx);
+    const items = (node as Record<string, unknown[]>).itemListElement as Record<string, unknown>[];
+    expect(items[0].item).toBe("https://example.com/de/");
+    expect(items[1].item).toBe("https://example.com/de/about/");
+  });
+
+  it("assigns position-scoped @id to each crumb", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "About", url: "https://example.com/de/about/" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildBreadcrumbNode(ctx);
+    const items = (node as Record<string, unknown[]>).itemListElement as Record<string, unknown>[];
+    expect(items[0]["@id"]).toBe(`${ctx.breadcrumbId}/1`);
+    expect(items[1]["@id"]).toBe(`${ctx.breadcrumbId}/2`);
+  });
+});

package/src/share/semantic/jsonld/tests/collection-list.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { buildCollectionListNode } from "../collection-list.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildCollectionListNode", () => {
+  it("returns null when page is not collection type", () => {
+    const page = makePage({ type: "content" });
+    const ctx = createJsonLdContext(page);
+    expect(buildCollectionListNode(ctx)).toBeNull();
+  });
+
+  it("returns null when collection has no items", () => {
+    const page = makePage({ type: "collection", collectionItems: [] });
+    const ctx = createJsonLdContext(page);
+    expect(buildCollectionListNode(ctx)).toBeNull();
+  });
+
+  it("builds ItemList for collection page with items", () => {
+    const page = makePage({
+      type: "collection",
+      collectionItems: [
+        { url: "https://example.com/de/industry-a/", name: "Industry A" },
+        { url: "https://example.com/de/industry-b/", name: "Industry B" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildCollectionListNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("ItemList");
+    expect(node!.itemListElement).toHaveLength(2);
+    const items = (node as Record<string, unknown[]>).itemListElement as Record<string, unknown>[];
+    expect(items[0]).toMatchObject({
+      position: 1,
+      url: "https://example.com/de/industry-a/",
+      name: "Industry A",
+    });
+  });
+});

package/src/share/semantic/jsonld/tests/faq.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { buildFaqNodes, buildFaqPageNode } from "../faq.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildFaqPageNode", () => {
+  it("returns null when no faqEntries", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildFaqPageNode(ctx)).toBeNull();
+  });
+
+  it("returns null when faqEntries is empty", () => {
+    const page = makePage({ faqEntries: [] });
+    const ctx = createJsonLdContext(page);
+    expect(buildFaqPageNode(ctx)).toBeNull();
+  });
+
+  it("builds FAQPage with Question nodes", () => {
+    const page = makePage({
+      faqEntries: [
+        { id: "q1", question: "What is this?", answer: "A test." },
+        { id: "q2", question: "How much?", answer: "Free." },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildFaqPageNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("FAQPage");
+    expect(node!.mainEntity).toHaveLength(2);
+    const entities = (node as Record<string, unknown[]>).mainEntity as Record<string, unknown>[];
+    expect(entities[0]).toEqual({
+      "@type": "Question",
+      name: "What is this?",
+      acceptedAnswer: { "@type": "Answer", text: "A test." },
+    });
+  });
+});
+
+describe("buildFaqNodes", () => {
+  it("suppresses FAQPage on ratgeber depth-1 article pages", () => {
+    const page = makePage({
+      surfaceId: "ratgeber",
+      depth: 1,
+      faqEntries: [{ id: "q1", question: "Q?", answer: "A." }],
+    });
+    const ctx = createJsonLdContext(page);
+    expect(buildFaqNodes(ctx)).toEqual([]);
+  });
+
+  it("emits FAQPage for non-ratgeber pages with FAQ entries", () => {
+    const page = makePage({
+      faqEntries: [{ id: "q1", question: "Q?", answer: "A." }],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildFaqNodes(ctx);
+    expect(nodes).toHaveLength(1);
+    expect(nodes[0]["@type"]).toBe("FAQPage");
+  });
+});

package/src/share/semantic/jsonld/tests/initiative.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { buildInitiativeNodes, buildInitiativesListNode } from "../initiative.ts";
+import { createJsonLdContext } from "../context.ts";
+import { makePage } from "../../tests/helpers.ts";
+
+describe("buildInitiativeNodes", () => {
+  it("returns empty array when no initiatives", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildInitiativeNodes(ctx)).toEqual([]);
+  });
+
+  it("builds Thing/Project nodes for each initiative", () => {
+    const page = makePage({
+      initiatives: [
+        { id: "i1", name: "Project Alpha", summary: "First project" },
+        { id: "i2", name: "Project Beta", summary: "Second project" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const nodes = buildInitiativeNodes(ctx);
+    expect(nodes).toHaveLength(2);
+    expect(nodes[0]["@type"]).toEqual(["Thing", "Project"]);
+    expect(nodes[0].name).toBe("Project Alpha");
+    expect(nodes[0].description).toBe("First project");
+    expect(nodes[1].name).toBe("Project Beta");
+  });
+});
+
+describe("buildInitiativesListNode", () => {
+  it("returns null when no initiatives", () => {
+    const page = makePage();
+    const ctx = createJsonLdContext(page);
+    expect(buildInitiativesListNode(ctx)).toBeNull();
+  });
+
+  it("builds ItemList with positioned initiatives", () => {
+    const page = makePage({
+      initiatives: [
+        { id: "i1", name: "Project Alpha", summary: "First" },
+        { id: "i2", name: "Project Beta", summary: "Second" },
+      ],
+    });
+    const ctx = createJsonLdContext(page);
+    const node = buildInitiativesListNode(ctx);
+    expect(node).not.toBeNull();
+    expect(node!["@type"]).toBe("ItemList");
+    expect(node!.itemListElement).toHaveLength(2);
+    expect(node as Record<string, unknown>).toMatchObject({
+      itemListElement: [
+        { position: 1, name: "Project Alpha" },
+        { position: 2, name: "Project Beta" },
+      ],
+    });
+  });
+});