@wildo-ai/saas-website 1.1.1

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import { WebsitePageRefSchema } from '../refs/page-ref.schemas';
+import { WebsiteSectionRefSchema } from '../refs/section-ref.schemas';
+
+describe('WebsitePageRefSchema', () => {
+  it('accepts kebab-case starting with a letter', () => {
+    expect(WebsitePageRefSchema.parse('landing')).toBe('landing');
+    expect(WebsitePageRefSchema.parse('pricing-tiers')).toBe('pricing-tiers');
+    expect(WebsitePageRefSchema.parse('contact-us-now-2')).toBe('contact-us-now-2');
+  });
+
+  it('rejects strings starting with a digit, hyphen, or upper-case letter', () => {
+    expect(() => WebsitePageRefSchema.parse('1landing')).toThrow();
+    expect(() => WebsitePageRefSchema.parse('-landing')).toThrow();
+    expect(() => WebsitePageRefSchema.parse('Landing')).toThrow();
+  });
+
+  it('rejects empty strings, snake_case, and over-long values', () => {
+    expect(() => WebsitePageRefSchema.parse('')).toThrow();
+    expect(() => WebsitePageRefSchema.parse('contact_us')).toThrow();
+    expect(() => WebsitePageRefSchema.parse('a'.repeat(65))).toThrow();
+  });
+});
+
+describe('WebsiteSectionRefSchema', () => {
+  it('accepts the same kebab-case shape as page refs', () => {
+    expect(WebsiteSectionRefSchema.parse('hero')).toBe('hero');
+    expect(WebsiteSectionRefSchema.parse('social-proof')).toBe('social-proof');
+  });
+
+  it('rejects whitespace, dot-paths, and slashes', () => {
+    expect(() => WebsiteSectionRefSchema.parse('hero section')).toThrow();
+    expect(() => WebsiteSectionRefSchema.parse('hero.cta')).toThrow();
+    expect(() => WebsiteSectionRefSchema.parse('hero/cta')).toThrow();
+  });
+});

package/src/schemas/__tests__/root-config.test.ts

@@ -0,0 +1,292 @@
+import type { ComponentType } from 'react';
+import { assertType, describe, expect, it } from 'vitest';
+
+import { WebsiteLabelKeySchema } from '../label-keys/website-label-key.schemas';
+import { WebsitePageManifestSchema } from '../manifests/website-page-manifest.shared.schemas';
+import {
+  WebsiteRobotsConfigSchema,
+  WebsiteRootConfigSchema,
+  WebsiteSitemapConfigSchema,
+  type WebsiteRootConfig,
+} from '../manifests/website-root-config.shared.schemas';
+import { WebsitePageRefSchema } from '../refs/page-ref.schemas';
+import { WebsiteSectionRefSchema } from '../refs/section-ref.schemas';
+
+const NoopComponent = () => null;
+
+const buildManifest = (ref: string, route: string) =>
+  WebsitePageManifestSchema.parse({
+    ref: WebsitePageRefSchema.parse(ref),
+    routePath: route,
+    pageComponent: NoopComponent,
+    sectionRefs: [WebsiteSectionRefSchema.parse('hero')],
+    metaLabelKeys: {
+      titleKey: WebsiteLabelKeySchema.parse(`website.${ref}.meta.title`),
+      descriptionKey: WebsiteLabelKeySchema.parse(`website.${ref}.meta.description`),
+    },
+  });
+
+const COLORS = {
+  background: '#fff',
+  foreground: '#111',
+  primary: '#0070f3',
+  primaryForeground: '#fff',
+  accent: '#ff5e5b',
+  accentForeground: '#fff',
+  surface: '#fafafa',
+  surfaceForeground: '#111',
+  border: '#e5e5e5',
+  muted: '#f5f5f5',
+  mutedForeground: '#737373',
+};
+
+const RADII = {
+  none: '0',
+  sm: '0.125rem',
+  md: '0.375rem',
+  lg: '0.75rem',
+  xl: '1.5rem',
+  full: '9999px',
+};
+
+const VALID_SEO = {
+  siteName: 'Example',
+};
+
+const SKIP_KEY = WebsiteLabelKeySchema.parse('website.chrome.layout.skip-to-main-content');
+
+const VALID_INPUT = {
+  pageManifests: [buildManifest('landing', '/'), buildManifest('pricing', '/pricing')],
+  designTokens: { colors: COLORS, radii: RADII },
+  navigation: { headerComponent: NoopComponent, footerComponent: NoopComponent },
+  seo: VALID_SEO,
+  skipToMainContentLabelKey: SKIP_KEY,
+};
+
+describe('WebsiteRootConfigSchema', () => {
+  it('parses a well-formed config', () => {
+    const parsed = WebsiteRootConfigSchema.parse(VALID_INPUT);
+    expect(parsed.pageManifests).toHaveLength(2);
+  });
+
+  it('rejects duplicate page refs', () => {
+    expect(() =>
+      WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        pageManifests: [buildManifest('landing', '/'), buildManifest('landing', '/landing-2')],
+      }),
+    ).toThrow(/Duplicate page ref/);
+  });
+
+  it('rejects duplicate route paths', () => {
+    expect(() =>
+      WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        pageManifests: [buildManifest('landing', '/'), buildManifest('home', '/')],
+      }),
+    ).toThrow(/Duplicate routePath/);
+  });
+
+  it('requires at least one page manifest', () => {
+    expect(() => WebsiteRootConfigSchema.parse({ ...VALID_INPUT, pageManifests: [] })).toThrow();
+  });
+
+  it('preserves ComponentType narrowing for pageComponent and navigation slots (compile-time, F5)', () => {
+    const config = WebsiteRootConfigSchema.parse(VALID_INPUT) as WebsiteRootConfig;
+    assertType<ComponentType<unknown>>(config.pageManifests[0]!.pageComponent);
+    assertType<ComponentType<unknown>>(config.navigation.headerComponent);
+    assertType<ComponentType<unknown>>(config.navigation.footerComponent);
+  });
+
+  describe('seo block (Phase 6 audit fix H-B/H-C/M-A — locales/origin moved to WildoMarketingWebsiteConfig in seam-collapse)', () => {
+    it('requires the seo block to be present', () => {
+      const { seo: _omit, ...withoutSeo } = VALID_INPUT;
+      expect(() => WebsiteRootConfigSchema.parse(withoutSeo)).toThrow();
+    });
+
+    it('rejects an empty siteName', () => {
+      expect(() =>
+        WebsiteRootConfigSchema.parse({
+          ...VALID_INPUT,
+          seo: { ...VALID_SEO, siteName: '' },
+        }),
+      ).toThrow(/siteName/);
+    });
+
+    it('accepts an optional defaultOgImageUrl as a fully-qualified URL', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, defaultOgImageUrl: 'https://cdn.example.com/og.png' },
+      });
+      expect(parsed.seo.defaultOgImageUrl).toBe('https://cdn.example.com/og.png');
+    });
+
+    it('rejects a non-URL defaultOgImageUrl', () => {
+      expect(() =>
+        WebsiteRootConfigSchema.parse({
+          ...VALID_INPUT,
+          seo: { ...VALID_SEO, defaultOgImageUrl: 'not-a-url' },
+        }),
+      ).toThrow(/defaultOgImageUrl.*URL/);
+    });
+  });
+
+  describe('seo.sitemap (Phase 8 close-out — saas-website-seo-sitemap.md)', () => {
+    it('omits the sitemap block by default (consumer opts in to overrides)', () => {
+      const parsed = WebsiteRootConfigSchema.parse(VALID_INPUT);
+      expect(parsed.seo.sitemap).toBeUndefined();
+    });
+
+    it('accepts an empty sitemap block and applies the enabled=true default', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, sitemap: {} },
+      });
+      expect(parsed.seo.sitemap?.enabled).toBe(true);
+    });
+
+    it('accepts enabled=false (suppressed sitemap emission for staging surfaces)', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, sitemap: { enabled: false } },
+      });
+      expect(parsed.seo.sitemap?.enabled).toBe(false);
+    });
+
+    it('accepts the seven sitemap-spec changefreq values', () => {
+      for (const changefreq of [
+        'always',
+        'hourly',
+        'daily',
+        'weekly',
+        'monthly',
+        'yearly',
+        'never',
+      ] as const) {
+        const parsed = WebsiteSitemapConfigSchema.parse({ changefreq });
+        expect(parsed.changefreq).toBe(changefreq);
+      }
+    });
+
+    it('rejects a changefreq outside the sitemap spec', () => {
+      expect(() => WebsiteSitemapConfigSchema.parse({ changefreq: 'fortnightly' })).toThrow();
+    });
+
+    it('accepts priority within [0, 1]', () => {
+      expect(WebsiteSitemapConfigSchema.parse({ priority: 0 }).priority).toBe(0);
+      expect(WebsiteSitemapConfigSchema.parse({ priority: 0.5 }).priority).toBe(0.5);
+      expect(WebsiteSitemapConfigSchema.parse({ priority: 1 }).priority).toBe(1);
+    });
+
+    it('rejects priority outside the spec range', () => {
+      expect(() => WebsiteSitemapConfigSchema.parse({ priority: -0.1 })).toThrow(/priority/);
+      expect(() => WebsiteSitemapConfigSchema.parse({ priority: 1.1 })).toThrow(/priority/);
+    });
+  });
+
+  describe('seo.robots (Phase 8 close-out — saas-website-seo-sitemap.md)', () => {
+    it('omits the robots block by default (consumer opts in to overrides)', () => {
+      const parsed = WebsiteRootConfigSchema.parse(VALID_INPUT);
+      expect(parsed.seo.robots).toBeUndefined();
+    });
+
+    it('accepts an empty robots block and applies the policy=index default', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, robots: {} },
+      });
+      expect(parsed.seo.robots?.policy).toBe('index');
+    });
+
+    it('accepts policy=noindex (staging / private surfaces)', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, robots: { policy: 'noindex' } },
+      });
+      expect(parsed.seo.robots?.policy).toBe('noindex');
+    });
+
+    it('accepts disallow path-prefix entries', () => {
+      const parsed = WebsiteRobotsConfigSchema.parse({
+        disallow: ['/internal/', '/preview/', '/api/'],
+      });
+      expect(parsed.disallow).toEqual(['/internal/', '/preview/', '/api/']);
+    });
+
+    it('rejects disallow entries that do not start with "/"', () => {
+      expect(() => WebsiteRobotsConfigSchema.parse({ disallow: ['internal'] })).toThrow(/start with/);
+    });
+
+    it('accepts allowedCrawlers (deny-by-default policy direction)', () => {
+      const parsed = WebsiteRobotsConfigSchema.parse({
+        allowedCrawlers: ['Googlebot', 'Bingbot'],
+      });
+      expect(parsed.allowedCrawlers).toEqual(['Googlebot', 'Bingbot']);
+    });
+
+    it('accepts disallowedCrawlers (allow-by-default policy direction)', () => {
+      const parsed = WebsiteRobotsConfigSchema.parse({
+        disallowedCrawlers: ['GPTBot', 'CCBot'],
+      });
+      expect(parsed.disallowedCrawlers).toEqual(['GPTBot', 'CCBot']);
+    });
+
+    it('rejects mixing allowedCrawlers and disallowedCrawlers (mutually exclusive policy directions)', () => {
+      expect(() =>
+        WebsiteRobotsConfigSchema.parse({
+          allowedCrawlers: ['Googlebot'],
+          disallowedCrawlers: ['GPTBot'],
+        }),
+      ).toThrow(/mutually exclusive/);
+    });
+
+    it('rejects empty crawler tokens (would emit an unparseable User-agent line)', () => {
+      expect(() => WebsiteRobotsConfigSchema.parse({ allowedCrawlers: [''] })).toThrow();
+      expect(() => WebsiteRobotsConfigSchema.parse({ disallowedCrawlers: [''] })).toThrow();
+    });
+  });
+
+  describe('seo.llmsTxt (AEO/GEO Step 4a)', () => {
+    it('omits the llmsTxt block by default (helper auto-detects from file presence)', () => {
+      const parsed = WebsiteRootConfigSchema.parse(VALID_INPUT);
+      expect(parsed.seo.llmsTxt).toBeUndefined();
+    });
+
+    it('accepts an empty llmsTxt block (enabled remains undefined for auto-detect)', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, llmsTxt: {} },
+      });
+      expect(parsed.seo.llmsTxt?.enabled).toBeUndefined();
+    });
+
+    it('accepts enabled=false (consumer suppresses publication even if the file exists)', () => {
+      const parsed = WebsiteRootConfigSchema.parse({
+        ...VALID_INPUT,
+        seo: { ...VALID_SEO, llmsTxt: { enabled: false } },
+      });
+      expect(parsed.seo.llmsTxt?.enabled).toBe(false);
+    });
+  });
+
+  describe('skipToMainContentLabelKey (Phase 6 third audit fix M-α)', () => {
+    it('requires the skipToMainContentLabelKey to be present', () => {
+      const { skipToMainContentLabelKey: _omit, ...withoutKey } = VALID_INPUT;
+      expect(() => WebsiteRootConfigSchema.parse(withoutKey)).toThrow();
+    });
+
+    it('rejects a malformed label key', () => {
+      expect(() =>
+        WebsiteRootConfigSchema.parse({
+          ...VALID_INPUT,
+          skipToMainContentLabelKey: 'not-a-website-label-key',
+        }),
+      ).toThrow();
+    });
+
+    it('accepts a fully-composed website.* label key', () => {
+      const parsed = WebsiteRootConfigSchema.parse(VALID_INPUT);
+      expect(parsed.skipToMainContentLabelKey).toBe(SKIP_KEY);
+    });
+  });
+});

package/src/schemas/__tests__/section-definition.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+
+import { WebsiteLabelKeySchema } from '../label-keys/website-label-key.schemas';
+import { WebsiteSectionRefSchema } from '../refs/section-ref.schemas';
+import { WebsiteSectionCategory } from '../sections/website-section-category.shared';
+import { WebsiteSectionDefinitionSchema } from '../sections/website-section-definition.shared.schemas';
+
+describe('WebsiteSectionDefinitionSchema', () => {
+  it('parses a well-formed definition with a Component reference', () => {
+    const Component = () => null;
+    const def = WebsiteSectionDefinitionSchema.parse({
+      sectionRef: WebsiteSectionRefSchema.parse('hero'),
+      category: WebsiteSectionCategory.HERO,
+      expectedLabelKeys: [
+        WebsiteLabelKeySchema.parse('website.landing.hero.headline'),
+        WebsiteLabelKeySchema.parse('website.landing.hero.subheadline'),
+      ],
+      Component,
+    });
+    expect(def.sectionRef).toBe('hero');
+    expect(def.category).toBe(WebsiteSectionCategory.HERO);
+    expect(def.expectedLabelKeys).toHaveLength(2);
+  });
+
+  it('accepts an optional getStructuredData hook', () => {
+    expect(() =>
+      WebsiteSectionDefinitionSchema.parse({
+        sectionRef: WebsiteSectionRefSchema.parse('pricing'),
+        category: WebsiteSectionCategory.PRICING,
+        expectedLabelKeys: [],
+        Component: () => null,
+        getStructuredData: () => ({ '@type': 'Product' }),
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects invalid category values', () => {
+    expect(() =>
+      WebsiteSectionDefinitionSchema.parse({
+        sectionRef: WebsiteSectionRefSchema.parse('hero'),
+        category: 'novel-category',
+        expectedLabelKeys: [],
+        Component: () => null,
+      }),
+    ).toThrow();
+  });
+});