@warpgogol/werkstatt-shared 0.14.0 → 0.15.0

package/src/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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();
+  });
+});

package/src/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/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/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/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);
+  });
+});