@warpgogol/werkstatt-shared 0.14.0 → 0.15.0

package/src/semantic/tests/breadcrumbs.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildBreadcrumbTrail,
+  stripSiteNameFromTitle,
+  surfaceAncestorPageIds,
+  type BreadcrumbAncestorResolver,
+} from "../breadcrumbs.ts";
+
+describe("stripSiteNameFromTitle", () => {
+  it("strips site name suffix", () => {
+    expect(stripSiteNameFromTitle("About | Warpgogol")).toBe("About");
+  });
+
+  it("returns title unchanged when no separator", () => {
+    expect(stripSiteNameFromTitle("About")).toBe("About");
+  });
+
+  it("trims whitespace", () => {
+    expect(stripSiteNameFromTitle("  About  ")).toBe("About");
+  });
+});
+
+describe("surfaceAncestorPageIds", () => {
+  it("returns empty for non-surface pageId", () => {
+    expect(surfaceAncestorPageIds("some-page")).toEqual([]);
+  });
+
+  it("returns empty for depth-0 root landing", () => {
+    expect(surfaceAncestorPageIds("industry:_root")).toEqual([]);
+  });
+
+  it("returns root + intermediate ancestors for depth-2", () => {
+    expect(surfaceAncestorPageIds("industry:tech:saas")).toEqual([
+      "industry:_root",
+      "industry:tech",
+    ]);
+  });
+});
+
+describe("buildBreadcrumbTrail", () => {
+  const noopResolver: BreadcrumbAncestorResolver = {
+    resolveAncestors: async () => [],
+  };
+
+  it("builds [Home, self] trail with no ancestors", async () => {
+    const trail = await buildBreadcrumbTrail({
+      pageId: "about",
+      pageTitle: "About | Site",
+      selfUrl: "https://example.com/de/about/",
+      homeLabel: "Home",
+      homeUrl: "https://example.com/de/",
+      lang: "de",
+      defaultLang: "de",
+      resolver: noopResolver,
+    });
+    expect(trail).toHaveLength(2);
+    expect(trail[0]).toEqual({ name: "Home", url: "https://example.com/de/" });
+    expect(trail[1]).toEqual({
+      name: "About",
+      url: "https://example.com/de/about/",
+      pageId: "about",
+    });
+  });
+
+  it("inserts ancestors between Home and self", async () => {
+    const resolver: BreadcrumbAncestorResolver = {
+      resolveAncestors: async () => [
+        { name: "Section", url: "https://example.com/de/section/" },
+      ],
+    };
+    const trail = await buildBreadcrumbTrail({
+      pageId: "page",
+      pageTitle: "Page",
+      selfUrl: "https://example.com/de/section/page/",
+      homeLabel: "Home",
+      homeUrl: "https://example.com/de/",
+      lang: "de",
+      defaultLang: "de",
+      resolver,
+    });
+    expect(trail).toHaveLength(3);
+    expect(trail[1]).toEqual({ name: "Section", url: "https://example.com/de/section/" });
+  });
+
+  it("deduplicates ancestors that collapse onto Home or self", async () => {
+    const resolver: BreadcrumbAncestorResolver = {
+      resolveAncestors: async () => [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "Self", url: "https://example.com/de/page/" },
+        { name: "Real Ancestor", url: "https://example.com/de/real/" },
+      ],
+    };
+    const trail = await buildBreadcrumbTrail({
+      pageId: "page",
+      pageTitle: "Page",
+      selfUrl: "https://example.com/de/page/",
+      homeLabel: "Home",
+      homeUrl: "https://example.com/de/",
+      lang: "de",
+      defaultLang: "de",
+      resolver,
+    });
+    expect(trail).toHaveLength(3);
+    expect(trail[1]).toEqual({ name: "Real Ancestor", url: "https://example.com/de/real/" });
+  });
+
+  it("drops ancestors with empty names", async () => {
+    const resolver: BreadcrumbAncestorResolver = {
+      resolveAncestors: async () => [
+        { name: "  ", url: "https://example.com/de/empty/" },
+        { name: "Valid", url: "https://example.com/de/valid/" },
+      ],
+    };
+    const trail = await buildBreadcrumbTrail({
+      pageId: "page",
+      pageTitle: "Page",
+      selfUrl: "https://example.com/de/page/",
+      homeLabel: "Home",
+      homeUrl: "https://example.com/de/",
+      lang: "de",
+      defaultLang: "de",
+      resolver,
+    });
+    expect(trail).toHaveLength(3);
+    expect(trail[1]).toEqual({ name: "Valid", url: "https://example.com/de/valid/" });
+  });
+});

package/src/{share → semantic}/tests/build-page-price-markers.test.ts

@@ -10,8 +10,8 @@ import {
   buildSemanticPageModelWith,
   type SemanticContentReader,
   type SemanticBuildProfile,
-} from "../semantic/build-page.ts";
-import { OFFERING_URI_PREFIX, type DerivedPriceEntry } from "../semantic/price-marker-resolver.ts";
+} from "../build-page.ts";
+import { OFFERING_URI_PREFIX, type DerivedPriceEntry } from "../price-marker-resolver.ts";
 
 const fixturePrices: Record<string, DerivedPriceEntry[]> = {
   [`${OFFERING_URI_PREFIX}referral-fee`]: [

package/src/semantic/tests/build-page.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "vitest";
+import { buildSemanticPageModelWith } from "../build-page.ts";
+import type { SemanticContentReader } from "../build-page.ts";
+
+function makeReader(overrides: Partial<SemanticContentReader> = {}): SemanticContentReader {
+  return {
+    getPageFrontmatter: async () => ({
+      title: "Test Page",
+      description: "A test page",
+      blocks: [],
+    }),
+    getProseBody: async () => "",
+    getHomeLabel: async () => "Home",
+    getFaqEntries: async () => [],
+    getDerivedPrices: () => null,
+    ...overrides,
+  };
+}
+
+const baseArgs = {
+  pageId: "test-page",
+  semanticType: "content" as const,
+  lang: "de",
+  url: "https://example.com/de/page/",
+  profile: {
+    organization: { name: "Org", description: "Desc", url: "https://example.com" },
+    people: [],
+    initiatives: [],
+  },
+};
+
+describe("buildSemanticPageModelWith", () => {
+  it("builds a SemanticPageModel from reader frontmatter", async () => {
+    const reader = makeReader();
+    const result = await buildSemanticPageModelWith(reader, baseArgs);
+    expect(result).not.toBeNull();
+    expect(result!.title).toBe("Test Page");
+    expect(result!.description).toBe("A test page");
+    expect(result!.lang).toBe("de");
+  });
+
+  it("returns null when reader returns null frontmatter and no fallback", async () => {
+    const reader = makeReader({ getPageFrontmatter: async () => null });
+    const result = await buildSemanticPageModelWith(reader, baseArgs);
+    expect(result).toBeNull();
+  });
+
+  it("uses fallbackFrontmatter when reader returns null", async () => {
+    const reader = makeReader({ getPageFrontmatter: async () => null });
+    const result = await buildSemanticPageModelWith(reader, {
+      ...baseArgs,
+      fallbackFrontmatter: { title: "Fallback", description: "Fallback desc", blocks: [] },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.title).toBe("Fallback");
+  });
+
+  it("attaches people for about pages", async () => {
+    const reader = makeReader();
+    const result = await buildSemanticPageModelWith(reader, {
+      ...baseArgs,
+      semanticType: "about",
+      profile: {
+        organization: { name: "Org", description: "Desc", url: "https://example.com" },
+        people: [{ name: "Jane", role: "CEO" }],
+        initiatives: [],
+      },
+    });
+    expect(result!.people).toEqual([{ name: "Jane", role: "CEO" }]);
+  });
+
+  it("attaches initiatives for projects pages", async () => {
+    const reader = makeReader();
+    const result = await buildSemanticPageModelWith(reader, {
+      ...baseArgs,
+      semanticType: "projects",
+      profile: {
+        organization: { name: "Org", description: "Desc", url: "https://example.com" },
+        people: [],
+        initiatives: [{ id: "i1", name: "Project", summary: "A project" }],
+      },
+    });
+    expect(result!.initiatives).toEqual([{ id: "i1", name: "Project", summary: "A project" }]);
+  });
+
+  it("attaches FAQ entries for donationContact pages", async () => {
+    const reader = makeReader({
+      getFaqEntries: async () => [{ id: "q1", question: "Q?", answer: "A." }],
+    });
+    const result = await buildSemanticPageModelWith(reader, {
+      ...baseArgs,
+      semanticType: "donationContact",
+    });
+    expect(result!.faqEntries).toEqual([{ id: "q1", question: "Q?", answer: "A." }]);
+  });
+
+  it("uses provided breadcrumbs when supplied", async () => {
+    const reader = makeReader();
+    const result = await buildSemanticPageModelWith(reader, {
+      ...baseArgs,
+      breadcrumbs: [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "Section", url: "https://example.com/de/section/" },
+        { name: "Page", url: "https://example.com/de/page/" },
+      ],
+    });
+    expect(result!.breadcrumbs).toHaveLength(3);
+  });
+
+  it("resolves price markers in heading and description", async () => {
+    const reader = makeReader({
+      getPageFrontmatter: async () => ({
+        title: "Pricing",
+        description: "Cost: {amount:50}",
+        blocks: [],
+      }),
+    });
+    const result = await buildSemanticPageModelWith(reader, baseArgs);
+    expect(result!.description).toContain("€");
+    expect(result!.description).not.toContain("{amount:");
+  });
+});

package/src/semantic/tests/business-projection.test.ts

@@ -0,0 +1,367 @@
+import { describe, expect, it } from "vitest";
+import {
+  BUSINESS_DOMAIN_VISIBILITY,
+  projectLocation,
+  projectOffer,
+  projectPeople,
+  projectServices,
+  projectWeb,
+  projectClaims,
+} from "../business-projection.ts";
+
+describe("BUSINESS_DOMAIN_VISIBILITY", () => {
+  it("marks company as public", () => {
+    expect(BUSINESS_DOMAIN_VISIBILITY.company).toBe("public");
+  });
+
+  it("marks compliance as none", () => {
+    expect(BUSINESS_DOMAIN_VISIBILITY.compliance).toBe("none");
+  });
+
+  it("marks externalServices as none", () => {
+    expect(BUSINESS_DOMAIN_VISIBILITY.externalServices).toBe("none");
+  });
+
+  it("marks meta as pageMeta", () => {
+    expect(BUSINESS_DOMAIN_VISIBILITY.meta).toBe("pageMeta");
+  });
+});
+
+describe("projectOffer", () => {
+  it("returns undefined for no data", () => {
+    expect(projectOffer(undefined)).toBeUndefined();
+  });
+
+  it("projects prices with labels", () => {
+    const result = projectOffer({ price: { monthly: "10", yearly: "100" }, currency: "EUR" });
+    expect(result?.prices).toHaveLength(2);
+    expect(result?.prices![0]).toEqual({
+      id: "monthly",
+      label: "Monthly",
+      amount: "10",
+      currency: "EUR",
+    });
+  });
+
+  it("projects guarantees", () => {
+    const result = projectOffer({
+      guarantees: { availability: { label: "99.9% Uptime", detail: "SLA guaranteed" } },
+    });
+    expect(result?.guarantees).toHaveLength(1);
+    expect(result?.guarantees![0]).toEqual({
+      id: "availability",
+      label: "99.9% Uptime",
+      detail: "SLA guaranteed",
+    });
+  });
+
+  it("projects growth modules", () => {
+    const result = projectOffer({
+      growthModules: { pro: { label: "Pro", description: "Advanced features", price: "50" } },
+    });
+    expect(result?.growthModules).toHaveLength(1);
+    expect(result?.growthModules![0]).toEqual({
+      id: "pro",
+      label: "Pro",
+      description: "Advanced features",
+      price: "50",
+    });
+  });
+
+  it("projects terms (changePrice, hourlyRate, billingDay)", () => {
+    const result = projectOffer({ changePrice: "5", hourlyRate: "80", billingDay: "15" });
+    expect(result?.changePrice).toBe("5");
+    expect(result?.hourlyRate).toBe("80");
+    expect(result?.billingDay).toBe("15");
+  });
+});
+
+describe("projectPeople", () => {
+  it("returns empty array for no records", () => {
+    expect(projectPeople(undefined)).toEqual([]);
+  });
+
+  it("projects people with name and role", () => {
+    const result = projectPeople([{ name: "Jane", role: "CEO", bio: "Leader" }]);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("Jane");
+    expect(result[0].role).toBe("CEO");
+    expect(result[0].description).toBe("Leader");
+  });
+
+  it("skips records without name", () => {
+    const result = projectPeople([{ role: "CEO" }, { name: "Jane" }]);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe("Jane");
+  });
+
+  it("maps sameAs and affiliations", () => {
+    const result = projectPeople([
+      {
+        name: "Jane",
+        sameAs: ["https://twitter.com/jane"],
+        affiliations: ["Org A"],
+      },
+    ]);
+    expect(result[0].sameAs).toEqual(["https://twitter.com/jane"]);
+    expect(result[0].affiliations).toEqual(["Org A"]);
+  });
+
+  it("maps birth/death dates", () => {
+    const result = projectPeople([{ name: "Jane", lifespan: { born: "1980", died: "2020" } }]);
+    expect(result[0].birthDate).toBe("1980");
+    expect(result[0].deathDate).toBe("2020");
+    expect(result[0].isDeceased).toBe(true);
+  });
+});
+
+describe("projectLocation", () => {
+  it("returns undefined for no data", () => {
+    expect(projectLocation(undefined)).toBeUndefined();
+  });
+
+  it("projects city, region, country", () => {
+    const result = projectLocation({
+      city: { name: "Berlin" },
+      region: { name: "BE" },
+      country: { name: "DE" },
+    });
+    expect(result?.locality).toBe("Berlin");
+    expect(result?.region).toBe("BE");
+    expect(result?.country).toBe("DE");
+  });
+
+  it("projects serviceArea", () => {
+    const result = projectLocation({ serviceArea: ["Berlin", "Potsdam"] });
+    expect(result?.serviceArea).toEqual(["Berlin", "Potsdam"]);
+  });
+
+  it("returns undefined when all fields empty", () => {
+    expect(projectLocation({})).toBeUndefined();
+  });
+});
+
+describe("projectServices", () => {
+  it("returns empty for no records", () => {
+    expect(projectServices(undefined)).toEqual([]);
+  });
+
+  it("projects services with name and description", () => {
+    const result = projectServices([
+      { name: "Hosting", slug: "hosting", description: "Web hosting" },
+    ]);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ id: "hosting", name: "Hosting", description: "Web hosting" });
+  });
+
+  it("uses name as id when slug missing", () => {
+    const result = projectServices([{ name: "Consulting" }]);
+    expect(result[0].id).toBe("Consulting");
+  });
+
+  it("drops records without name", () => {
+    expect(projectServices([{ description: "No name" }])).toEqual([]);
+  });
+});
+
+describe("projectWeb", () => {
+  it("returns undefined for no data", () => {
+    expect(projectWeb(undefined)).toBeUndefined();
+  });
+
+  it("projects primaryUrl and statusUrl", () => {
+    const result = projectWeb({
+      primaryUrl: "https://example.com",
+      statusUrl: "https://status.example.com",
+    });
+    expect(result?.primaryUrl).toBe("https://example.com");
+    expect(result?.statusUrl).toBe("https://status.example.com");
+  });
+
+  it("projects domains", () => {
+    const result = projectWeb({ domains: { primary: "example.com", german: "example.de" } });
+    expect(result?.domains).toEqual({ primary: "example.com", german: "example.de" });
+  });
+
+  it("returns undefined when all fields empty", () => {
+    expect(projectWeb({})).toBeUndefined();
+  });
+});
+
+describe("projectClaims", () => {
+  it("returns empty array for undefined claims", () => {
+    expect(projectClaims(undefined, undefined)).toEqual([]);
+  });
+
+  it("returns empty array for empty claims", () => {
+    expect(projectClaims([], undefined)).toEqual([]);
+  });
+
+  it("filters out non-published claims", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "draft",
+        statement: "Draft claim",
+        claimClass: "factual",
+        claimKind: "fact",
+      },
+      {
+        id: "c2",
+        status: "published",
+        statement: "Published claim",
+        claimClass: "factual",
+        claimKind: "fact",
+      },
+    ];
+    const result = projectClaims(claims, undefined);
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("c2");
+  });
+
+  it("skips claims without an id", () => {
+    const claims = [
+      { status: "published", statement: "No ID", claimClass: "factual", claimKind: "fact" },
+    ];
+    expect(projectClaims(claims, undefined)).toEqual([]);
+  });
+
+  it("projects claim fields", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "published",
+        statement: "We are awesome",
+        claimClass: "benefit",
+        claimKind: "benefit",
+        statementLang: "en",
+        verificationLevel: "N2",
+        confidence: "high",
+      },
+    ];
+    const result = projectClaims(claims, undefined);
+    expect(result[0]).toEqual({
+      id: "c1",
+      claimClass: "benefit",
+      claimKind: "benefit",
+      statement: "We are awesome",
+      statementLang: "en",
+      verificationLevel: "N2",
+      confidence: "high",
+      evidence: [],
+    });
+  });
+
+  it("resolves evidence refs using the ref field", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "published",
+        statement: "Claim with evidence",
+        claimClass: "factual",
+        claimKind: "fact",
+        evidenceRefs: { ev1: { ref: "evidence-1" } },
+      },
+    ];
+    const evidenceSources = {
+      "evidence-1": {
+        id: "evidence-1",
+        kind: "verified-record",
+        name: "Audit Report",
+        items: { item1: { sha256: "abc123", canonical: true } },
+        canonicalUri: "https://example.com/evidence/1",
+      },
+    };
+    const result = projectClaims(claims, evidenceSources);
+    expect(result[0].evidence).toHaveLength(1);
+    expect(result[0].evidence[0]).toEqual({
+      id: "evidence-1",
+      kind: "verified-record",
+      label: "Audit Report",
+      sha256: "abc123",
+      canonicalUri: "https://example.com/evidence/1",
+    });
+  });
+
+  it("falls back to first item when no canonical item exists", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "published",
+        statement: "Claim",
+        claimClass: "factual",
+        claimKind: "fact",
+        evidenceRefs: { ev1: { ref: "evidence-1" } },
+      },
+    ];
+    const evidenceSources = {
+      "evidence-1": {
+        id: "evidence-1",
+        kind: "certificate",
+        name: "ISO Certificate",
+        items: {
+          item1: { sha256: "first-hash" },
+          item2: { sha256: "second-hash", canonical: true },
+        },
+      },
+    };
+    const result = projectClaims(claims, evidenceSources);
+    expect(result[0].evidence[0].sha256).toBe("second-hash");
+  });
+
+  it("uses first item when no canonical flag at all", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "published",
+        statement: "Claim",
+        claimClass: "factual",
+        claimKind: "fact",
+        evidenceRefs: { ev1: { ref: "evidence-1" } },
+      },
+    ];
+    const evidenceSources = {
+      "evidence-1": {
+        id: "evidence-1",
+        kind: "certificate",
+        name: "ISO Certificate",
+        items: { item1: { sha256: "only-hash" } },
+      },
+    };
+    const result = projectClaims(claims, evidenceSources);
+    expect(result[0].evidence[0].sha256).toBe("only-hash");
+  });
+
+  it("skips evidence refs that point to missing sources", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "published",
+        statement: "Claim",
+        claimClass: "factual",
+        claimKind: "fact",
+        evidenceRefs: { ev1: { ref: "missing" } },
+      },
+    ];
+    const result = projectClaims(claims, undefined);
+    expect(result[0].evidence).toEqual([]);
+  });
+
+  it("uses sourceId as label when name is missing", () => {
+    const claims = [
+      {
+        id: "c1",
+        status: "published",
+        statement: "Claim",
+        claimClass: "factual",
+        claimKind: "fact",
+        evidenceRefs: { ev1: { ref: "evidence-1" } },
+      },
+    ];
+    const evidenceSources = {
+      "evidence-1": { id: "evidence-1", kind: "registry" },
+    };
+    const result = projectClaims(claims, evidenceSources);
+    expect(result[0].evidence[0].label).toBe("evidence-1");
+  });
+});

package/src/semantic/tests/canonical-uri.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { deriveCanonicalUri } from "../canonical-uri.ts";
+
+describe("RFC-1075 AC-4: deriveCanonicalUri is pure and deterministic", () => {
+  it("returns undefined for undefined siteOrigin", () => {
+    expect(deriveCanonicalUri(undefined, "business")).toBeUndefined();
+    expect(deriveCanonicalUri(undefined, "offering", "off-1")).toBeUndefined();
+  });
+
+  it("returns undefined for empty siteOrigin", () => {
+    expect(deriveCanonicalUri("", "business")).toBeUndefined();
+    expect(deriveCanonicalUri("", "offering", "off-1")).toBeUndefined();
+  });
+
+  it("derives business URI without entityId", () => {
+    expect(deriveCanonicalUri("https://example.example", "business")).toBe(
+      "https://example.example/.well-known/entity/business",
+    );
+  });
+
+  it("derives offering URI with entityId", () => {
+    expect(deriveCanonicalUri("https://example.example", "offering", "off-1")).toBe(
+      "https://example.example/.well-known/entity/offering/off-1",
+    );
+  });
+
+  it("returns undefined for offering without entityId", () => {
+    expect(deriveCanonicalUri("https://example.example", "offering")).toBeUndefined();
+    expect(deriveCanonicalUri("https://example.example", "offering", "")).toBeUndefined();
+  });
+
+  it("strips trailing slashes from siteOrigin", () => {
+    expect(deriveCanonicalUri("https://example.example/", "business")).toBe(
+      "https://example.example/.well-known/entity/business",
+    );
+    expect(deriveCanonicalUri("https://example.example//", "business")).toBe(
+      "https://example.example/.well-known/entity/business",
+    );
+  });
+
+  it("is deterministic — same inputs always produce same output", () => {
+    const inputs = ["https://example.example", "https://example.example/"] as const;
+    for (const origin of inputs) {
+      const a = deriveCanonicalUri(origin, "offering", "off-1");
+      const b = deriveCanonicalUri(origin, "offering", "off-1");
+      expect(a).toBe(b);
+    }
+  });
+
+  it("is side-effect-free — does not mutate inputs", () => {
+    const origin = "https://example.example";
+    const before = origin;
+    deriveCanonicalUri(origin, "business");
+    expect(origin).toBe(before);
+  });
+});