@warpgogol/werkstatt-shared 0.14.0 → 0.14.1

package/src/share/schemas/tests/effects.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect } from "vitest";
+import {
+  namedEffectTargetSchema,
+  effectTargetSchema,
+  glassEffectSchema,
+  effectSchema,
+  EFFECT_KIND_META,
+  allowedKindsForTarget,
+  resolveEffectsForTarget,
+  hasEnabledGlassEffect,
+} from "../effects.ts";
+import type { EffectAssignment } from "../effects.ts";
+import { z } from "zod";
+
+type ParsedEffect = z.infer<typeof effectSchema>;
+
+describe("namedEffectTargetSchema", () => {
+  it("accepts valid targets", () => {
+    expect(namedEffectTargetSchema.parse("section")).toBe("section");
+    expect(namedEffectTargetSchema.parse("heading")).toBe("heading");
+  });
+
+  it("rejects invalid target", () => {
+    expect(() => namedEffectTargetSchema.parse("unknown")).toThrow();
+  });
+});
+
+describe("effectTargetSchema", () => {
+  it("accepts slot targets", () => {
+    expect(effectTargetSchema.parse("slot:my-slot")).toBe("slot:my-slot");
+  });
+
+  it("rejects invalid slot format", () => {
+    expect(() => effectTargetSchema.parse("slot:")).toThrow();
+  });
+});
+
+describe("glassEffectSchema", () => {
+  it("accepts valid glass effect", () => {
+    const result = glassEffectSchema.safeParse({ kind: "glass", enabled: true });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects missing required fields", () => {
+    expect(() => glassEffectSchema.parse({ kind: "glass" })).toThrow();
+  });
+
+  it("rejects extra keys (strict)", () => {
+    expect(() => glassEffectSchema.parse({ kind: "glass", enabled: true, extra: true })).toThrow();
+  });
+});
+
+describe("effectSchema (discriminated union)", () => {
+  it("accepts glass effect", () => {
+    const result = effectSchema.safeParse({ kind: "glass", enabled: true });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts shadow effect", () => {
+    const result = effectSchema.safeParse({ kind: "shadow", enabled: true });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects unknown kind", () => {
+    expect(() => effectSchema.parse({ kind: "unknown", enabled: true })).toThrow();
+  });
+});
+
+describe("EFFECT_KIND_META", () => {
+  it("has metadata for all effect kinds", () => {
+    expect(EFFECT_KIND_META.glass.strategy).toBe("surface");
+    expect(EFFECT_KIND_META.shadow.strategy).toBe("text");
+  });
+});
+
+describe("allowedKindsForTarget", () => {
+  it("returns text kinds for heading", () => {
+    const kinds = allowedKindsForTarget("heading");
+    expect(kinds).toContain("shadow");
+    expect(kinds).not.toContain("glass");
+  });
+
+  it("returns glass-only default for body", () => {
+    const kinds = allowedKindsForTarget("body");
+    expect(kinds).toEqual(["glass"]);
+  });
+});
+
+describe("resolveEffectsForTarget", () => {
+  it("returns empty array when no assignments", () => {
+    expect(resolveEffectsForTarget(undefined, "section")).toEqual([]);
+  });
+
+  it("returns effects for matching target", () => {
+    const glassEffect: ParsedEffect = effectSchema.parse({ kind: "glass", enabled: true });
+    const assignments: EffectAssignment[] = [{ target: "section", stack: [glassEffect] }];
+    const effects = resolveEffectsForTarget(assignments, "section");
+    expect(effects).toHaveLength(1);
+  });
+});
+
+describe("hasEnabledGlassEffect", () => {
+  it("returns true when glass effect is enabled", () => {
+    const e: ParsedEffect = effectSchema.parse({ kind: "glass", enabled: true });
+    expect(hasEnabledGlassEffect([e])).toBe(true);
+  });
+
+  it("returns false when glass effect is disabled", () => {
+    const e: ParsedEffect = effectSchema.parse({ kind: "glass", enabled: false });
+    expect(hasEnabledGlassEffect([e])).toBe(false);
+  });
+
+  it("returns false when no effects", () => {
+    expect(hasEnabledGlassEffect(undefined)).toBe(false);
+  });
+});

package/src/share/schemas/tests/features.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import {
+  featurePolicyVisibilitySchema,
+  featurePolicyBehaviorValueSchema,
+  featurePolicySchema,
+} from "../features.ts";
+
+describe("featurePolicyVisibilitySchema", () => {
+  it("accepts valid visibility values", () => {
+    for (const v of ["enabled", "disabled", "hidden", "draft"]) {
+      expect(featurePolicyVisibilitySchema.parse(v)).toBe(v);
+    }
+  });
+
+  it("rejects invalid values", () => {
+    expect(() => featurePolicyVisibilitySchema.parse("visible")).toThrow();
+  });
+});
+
+describe("featurePolicyBehaviorValueSchema", () => {
+  it("accepts string values", () => {
+    expect(featurePolicyBehaviorValueSchema.parse("hello")).toBe("hello");
+  });
+
+  it("accepts number values", () => {
+    expect(featurePolicyBehaviorValueSchema.parse(42)).toBe(42);
+  });
+
+  it("accepts boolean values", () => {
+    expect(featurePolicyBehaviorValueSchema.parse(true)).toBe(true);
+  });
+
+  it("accepts null", () => {
+    expect(featurePolicyBehaviorValueSchema.parse(null)).toBeNull();
+  });
+
+  it("rejects objects", () => {
+    expect(() => featurePolicyBehaviorValueSchema.parse({})).toThrow();
+  });
+});
+
+describe("featurePolicySchema", () => {
+  it("accepts empty object (all fields optional)", () => {
+    expect(featurePolicySchema.parse({})).toEqual({});
+  });
+
+  it("accepts full policy", () => {
+    const policy = {
+      visibility: "enabled",
+      behavior: { key: "value" },
+      reason: "test",
+      expiresAt: "2026-12-31",
+      audience: "all",
+    };
+    expect(featurePolicySchema.parse(policy)).toEqual(policy);
+  });
+
+  it("rejects invalid visibility", () => {
+    expect(() => featurePolicySchema.parse({ visibility: "invalid" })).toThrow();
+  });
+});

package/src/share/schemas/tests/horizontal-align.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { horizontalAlignSchema } from "../horizontal-align.ts";
+
+describe("horizontalAlignSchema", () => {
+  it("accepts valid alignment values", () => {
+    expect(horizontalAlignSchema.parse("left")).toBe("left");
+    expect(horizontalAlignSchema.parse("center")).toBe("center");
+    expect(horizontalAlignSchema.parse("right")).toBe("right");
+  });
+
+  it("rejects invalid alignment values", () => {
+    expect(() => horizontalAlignSchema.parse("top")).toThrow();
+    expect(() => horizontalAlignSchema.parse("")).toThrow();
+    expect(() => horizontalAlignSchema.parse(null)).toThrow();
+  });
+});

package/src/share/schemas/tests/icon-color.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { iconColorSchema } from "../icon-color.ts";
+
+describe("iconColorSchema", () => {
+  it("accepts valid icon colors", () => {
+    for (const c of ["primary", "accent", "success", "warning", "error", "muted"]) {
+      expect(iconColorSchema.parse(c)).toBe(c);
+    }
+  });
+
+  it("rejects invalid icon colors", () => {
+    expect(() => iconColorSchema.parse("blue")).toThrow();
+    expect(() => iconColorSchema.parse("")).toThrow();
+    expect(() => iconColorSchema.parse(123)).toThrow();
+  });
+});

package/src/share/schemas/tests/live-photo.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { livePhotoTriggerSchema, livePhotoSchema } from "../live-photo.ts";
+
+describe("livePhotoTriggerSchema", () => {
+  it("accepts valid triggers", () => {
+    for (const t of ["in-viewport", "tap", "autoplay"]) {
+      expect(livePhotoTriggerSchema.parse(t)).toBe(t);
+    }
+  });
+
+  it("rejects invalid trigger", () => {
+    expect(() => livePhotoTriggerSchema.parse("scroll")).toThrow();
+  });
+});
+
+describe("livePhotoSchema", () => {
+  it("accepts minimal valid object with defaults", () => {
+    const result = livePhotoSchema.parse({ enabled: true });
+    expect(result.enabled).toBe(true);
+  });
+
+  it("accepts full config", () => {
+    const config = {
+      enabled: true,
+      trigger: "in-viewport",
+      loop: true,
+      tapBehavior: "toggle",
+      preload: "metadata",
+    };
+    expect(livePhotoSchema.parse(config)).toEqual(config);
+  });
+
+  it("rejects unknown keys (strict)", () => {
+    expect(() => livePhotoSchema.parse({ enabled: true, unknown: true })).toThrow();
+  });
+
+  it("rejects invalid trigger", () => {
+    expect(() => livePhotoSchema.parse({ enabled: true, trigger: "scroll" })).toThrow();
+  });
+});

package/src/share/schemas/tests/material-credit.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import {
+  materialKindSchema,
+  materialSourceTypeSchema,
+  creditPartyKindSchema,
+  creditRoleSchema,
+} from "../material-credit.ts";
+
+describe("materialKindSchema", () => {
+  it("accepts valid kinds", () => {
+    const result = materialKindSchema.safeParse("image");
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid kind", () => {
+    expect(() => materialKindSchema.parse("3d-model")).toThrow();
+  });
+});
+
+describe("materialSourceTypeSchema", () => {
+  it("accepts valid source types", () => {
+    const result = materialSourceTypeSchema.safeParse("human-made");
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid source type", () => {
+    expect(() => materialSourceTypeSchema.parse("unknown")).toThrow();
+  });
+});
+
+describe("creditPartyKindSchema", () => {
+  it("accepts valid party kinds", () => {
+    const result = creditPartyKindSchema.safeParse("Person");
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid party kind", () => {
+    expect(() => creditPartyKindSchema.parse("Robot")).toThrow();
+  });
+});
+
+describe("creditRoleSchema", () => {
+  it("accepts valid roles", () => {
+    const result = creditRoleSchema.safeParse("creator");
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid role", () => {
+    expect(() => creditRoleSchema.parse("owner")).toThrow();
+  });
+});

package/src/share/schemas/tests/media.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import { mediaProfileSchema, mediaTriggerSchema } from "../media.ts";
+
+describe("mediaProfileSchema", () => {
+  it("accepts valid profiles", () => {
+    for (const p of ["feature", "background", "ambient"]) {
+      expect(mediaProfileSchema.parse(p)).toBe(p);
+    }
+  });
+
+  it("rejects invalid profile", () => {
+    expect(() => mediaProfileSchema.parse("streaming")).toThrow();
+  });
+});
+
+describe("mediaTriggerSchema", () => {
+  it("accepts valid triggers", () => {
+    for (const t of ["in-viewport", "tap", "autoplay"]) {
+      expect(mediaTriggerSchema.parse(t)).toBe(t);
+    }
+  });
+
+  it("rejects invalid trigger", () => {
+    expect(() => mediaTriggerSchema.parse("scroll")).toThrow();
+  });
+});

package/src/share/schemas/tests/navigation.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import {
+  createNavigationGroupEnum,
+  defaultNavigationGroups,
+  navigationTargetSchema,
+  navigationSchema,
+} from "../navigation.ts";
+
+describe("defaultNavigationGroups", () => {
+  it("contains expected groups", () => {
+    expect(defaultNavigationGroups).toEqual(["navigation", "legal", "contact"]);
+  });
+});
+
+describe("createNavigationGroupEnum", () => {
+  it("creates a Zod enum from group names", () => {
+    const enumSchema = createNavigationGroupEnum(["main", "footer"]);
+    expect(enumSchema.parse("main")).toBe("main");
+    expect(enumSchema.parse("footer")).toBe("footer");
+  });
+
+  it("rejects values not in the enum", () => {
+    const enumSchema = createNavigationGroupEnum(["main"]);
+    expect(() => enumSchema.parse("footer")).toThrow();
+  });
+});
+
+describe("navigationTargetSchema", () => {
+  it("validates a target with valid group", () => {
+    const groupEnum = createNavigationGroupEnum(["navigation", "legal"]);
+    const schema = navigationTargetSchema(groupEnum);
+    const result = schema.safeParse({
+      id: "home",
+      label: "Home",
+      semanticTarget: { kind: "internal", pageId: "home" },
+      group: "navigation",
+    });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("navigationSchema", () => {
+  it("validates a navigation object with targets", () => {
+    const groupEnum = createNavigationGroupEnum(["navigation"]);
+    const schema = navigationSchema(groupEnum);
+    const result = schema.safeParse({
+      targets: [
+        {
+          id: "home",
+          label: "Home",
+          semanticTarget: { kind: "internal", pageId: "home" },
+          group: "navigation",
+        },
+      ],
+    });
+    expect(result.success).toBe(true);
+  });
+});

package/src/share/schemas/tests/page-base.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { componentOverridesSchema } from "../page-base.ts";
+
+describe("componentOverridesSchema", () => {
+  it("accepts undefined (optional)", () => {
+    expect(componentOverridesSchema.parse(undefined)).toBeUndefined();
+  });
+
+  it("accepts empty record", () => {
+    expect(componentOverridesSchema.parse({})).toEqual({});
+  });
+
+  it("accepts a valid overrides map", () => {
+    const overrides = {
+      "components/Header": { title: "Custom" },
+    };
+    expect(componentOverridesSchema.parse(overrides)).toEqual(overrides);
+  });
+});

package/src/share/schemas/tests/participant.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import {
+  PARTICIPANT_TYPES,
+  PARTICIPANT_RELATIONSHIPS,
+  PARTICIPANT_STATUSES,
+} from "../participant.ts";
+
+describe("PARTICIPANT_TYPES", () => {
+  it("contains expected types", () => {
+    expect(PARTICIPANT_TYPES).toContain("human");
+    expect(PARTICIPANT_TYPES).toContain("ai-agent");
+    expect(PARTICIPANT_TYPES).toHaveLength(6);
+  });
+});
+
+describe("PARTICIPANT_RELATIONSHIPS", () => {
+  it("is a non-empty array", () => {
+    expect(PARTICIPANT_RELATIONSHIPS.length).toBeGreaterThan(0);
+  });
+});
+
+describe("PARTICIPANT_STATUSES", () => {
+  it("is a non-empty array", () => {
+    expect(PARTICIPANT_STATUSES.length).toBeGreaterThan(0);
+  });
+});

package/src/share/schemas/tests/person.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from "vitest";
+import { PERSON_AFFILIATIONS } from "../person.ts";
+
+describe("PERSON_AFFILIATIONS", () => {
+  it("contains the expected affiliation values", () => {
+    expect(PERSON_AFFILIATIONS).toEqual(["founder", "board", "team", "patron", "author"]);
+  });
+
+  it("is a readonly tuple", () => {
+    expect(PERSON_AFFILIATIONS).toHaveLength(5);
+  });
+});

package/src/share/schemas/tests/print.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import {
+  PRINT_ORIENTATIONS,
+  PRINT_PAGE_SIZES,
+  PRINT_MARGINS,
+  PRINT_BACKGROUND_MODES,
+  PRINT_REGIONS,
+} from "../print.ts";
+
+describe("print constants", () => {
+  it("PRINT_ORIENTATIONS has expected values", () => {
+    expect(PRINT_ORIENTATIONS).toEqual(["portrait", "landscape", "auto"]);
+  });
+
+  it("PRINT_PAGE_SIZES has expected values", () => {
+    expect(PRINT_PAGE_SIZES).toEqual(["a4", "letter", "legal"]);
+  });
+
+  it("PRINT_MARGINS has expected values", () => {
+    expect(PRINT_MARGINS).toEqual(["normal", "narrow", "none"]);
+  });
+
+  it("PRINT_BACKGROUND_MODES has expected values", () => {
+    expect(PRINT_BACKGROUND_MODES).toEqual(["preserve", "flatten"]);
+  });
+
+  it("PRINT_REGIONS is a non-empty array", () => {
+    expect(PRINT_REGIONS.length).toBeGreaterThan(0);
+  });
+});

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

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { sectionBackgroundSchema } from "../section-background.ts";
+
+describe("sectionBackgroundSchema", () => {
+  it("accepts color kind", () => {
+    const result = sectionBackgroundSchema.safeParse({ kind: "color" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts image kind with imageName", () => {
+    const result = sectionBackgroundSchema.safeParse({
+      kind: "image",
+      imageName: "hero-bg",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts transparent kind", () => {
+    const result = sectionBackgroundSchema.safeParse({ kind: "transparent" });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects invalid kind", () => {
+    expect(() => sectionBackgroundSchema.parse({ kind: "video" })).toThrow();
+  });
+
+  it("rejects image kind without imageName", () => {
+    const result = sectionBackgroundSchema.safeParse({ kind: "image" });
+    expect(result.success).toBe(false);
+  });
+});

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { sectionBodyKindSchema } from "../section-body.ts";
+
+describe("sectionBodyKindSchema", () => {
+  it("accepts valid body kinds", () => {
+    const validKinds = ["list", "split-list", "stats", "cards", "paragraphs", "comparison", "rich"];
+    for (const kind of validKinds) {
+      const result = sectionBodyKindSchema.safeParse(kind);
+      expect(result.success, `kind "${kind}" should be valid`).toBe(true);
+    }
+  });
+
+  it("rejects invalid body kind", () => {
+    expect(() => sectionBodyKindSchema.parse("accordion")).toThrow();
+  });
+});

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

@@ -0,0 +1,17 @@
+import { describe, it, expect } from "vitest";
+import { standardCardSchema } from "../section-cards.ts";
+
+describe("standardCardSchema", () => {
+  it("accepts a valid card", () => {
+    const result = standardCardSchema.safeParse({
+      title: "Test Card",
+      description: "Card body text",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects empty object", () => {
+    const result = standardCardSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+});

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

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import {
+  ctaVariantSchema,
+  ctaSizeSchema,
+  ctaIconPositionSchema,
+} from "../section-cta.ts";
+
+describe("ctaVariantSchema", () => {
+  it("accepts valid variants", () => {
+    for (const v of ["primary", "secondary", "ghost", "danger"]) {
+      expect(ctaVariantSchema.parse(v)).toBe(v);
+    }
+  });
+
+  it("rejects invalid variant", () => {
+    expect(() => ctaVariantSchema.parse("link")).toThrow();
+  });
+});
+
+describe("ctaSizeSchema", () => {
+  it("accepts valid sizes", () => {
+    for (const s of ["sm", "md", "lg"]) {
+      expect(ctaSizeSchema.parse(s)).toBe(s);
+    }
+  });
+
+  it("rejects invalid size", () => {
+    expect(() => ctaSizeSchema.parse("xl")).toThrow();
+  });
+});
+
+describe("ctaIconPositionSchema", () => {
+  it("accepts valid positions", () => {
+    expect(ctaIconPositionSchema.parse("leading")).toBe("leading");
+    expect(ctaIconPositionSchema.parse("trailing")).toBe("trailing");
+  });
+
+  it("rejects invalid position", () => {
+    expect(() => ctaIconPositionSchema.parse("top")).toThrow();
+  });
+});

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

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import {
+  headingToneSchema,
+  sectionHeaderLevelSchema,
+} from "../section-header.ts";
+
+describe("headingToneSchema", () => {
+  it("accepts valid tones", () => {
+    for (const t of ["default", "primary", "accent", "muted", "inverse"]) {
+      expect(headingToneSchema.parse(t)).toBe(t);
+    }
+  });
+
+  it("rejects invalid tone", () => {
+    expect(() => headingToneSchema.parse("bright")).toThrow();
+  });
+});
+
+describe("sectionHeaderLevelSchema", () => {
+  it("accepts level 1", () => {
+    expect(sectionHeaderLevelSchema.parse(1)).toBe(1);
+  });
+
+  it("accepts level 2", () => {
+    expect(sectionHeaderLevelSchema.parse(2)).toBe(2);
+  });
+
+  it("rejects level 3", () => {
+    expect(() => sectionHeaderLevelSchema.parse(3)).toThrow();
+  });
+});

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

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { sectionImageParallaxPropSchema } from "../section-image.ts";
+
+describe("sectionImageParallaxPropSchema", () => {
+  it("accepts boolean", () => {
+    expect(sectionImageParallaxPropSchema.parse(true)).toBe(true);
+    expect(sectionImageParallaxPropSchema.parse(false)).toBe(false);
+  });
+
+  it("accepts number in range 0..2", () => {
+    expect(sectionImageParallaxPropSchema.parse(0)).toBe(0);
+    expect(sectionImageParallaxPropSchema.parse(1)).toBe(1);
+    expect(sectionImageParallaxPropSchema.parse(2)).toBe(2);
+  });
+
+  it("rejects number out of range", () => {
+    expect(() => sectionImageParallaxPropSchema.parse(3)).toThrow();
+    expect(() => sectionImageParallaxPropSchema.parse(-1)).toThrow();
+  });
+
+  it("rejects string", () => {
+    expect(() => sectionImageParallaxPropSchema.parse("subtle")).toThrow();
+  });
+});

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

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import {
+  revealVariantSchema,
+  parallaxVariantSchema,
+} from "../section-motion.ts";
+
+describe("revealVariantSchema", () => {
+  it("accepts valid variants", () => {
+    for (const v of ["fade", "fade-up", "fade-up-stagger"]) {
+      expect(revealVariantSchema.parse(v)).toBe(v);
+    }
+  });
+
+  it("rejects invalid variant", () => {
+    expect(() => revealVariantSchema.parse("slide")).toThrow();
+  });
+});
+
+describe("parallaxVariantSchema", () => {
+  it("accepts valid variants", () => {
+    for (const v of ["subtle", "balanced", "dramatic"]) {
+      expect(parallaxVariantSchema.parse(v)).toBe(v);
+    }
+  });
+
+  it("rejects invalid variant", () => {
+    expect(() => parallaxVariantSchema.parse("extreme")).toThrow();
+  });
+});