@wildo-ai/saas-website 1.1.1

package/src/components/low-level/__tests__/WebsiteInternalLink.test.tsx

@@ -0,0 +1,202 @@
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+
+import { WebsiteRuntimeContextProvider } from '../../../core/contexts/WebsiteRuntimeContext';
+import { WebsiteLabelKeySchema } from '../../../schemas/label-keys/website-label-key.schemas';
+
+import { WebsiteInternalLink } from '../WebsiteInternalLink';
+
+const SKIP_KEY = WebsiteLabelKeySchema.parse('website.chrome.layout.skip-to-main-content');
+
+function renderWithRuntime(
+  ui: React.ReactNode,
+  opts: { locale: AvailableLanguage; defaultLocale: AvailableLanguage },
+): ReturnType<typeof render> {
+  return render(
+    <WebsiteRuntimeContextProvider
+      value={{
+        locale: opts.locale,
+        defaultLocale: opts.defaultLocale,
+        labelPack: {},
+        designTokens: {
+          colors: {
+            background: '#fff',
+            foreground: '#111',
+            primary: '#0070f3',
+            primaryForeground: '#fff',
+            accent: '#ff5e5b',
+            accentForeground: '#fff',
+            surface: '#fafafa',
+            surfaceForeground: '#111',
+            border: '#e5e5e5',
+            muted: '#f5f5f5',
+            mutedForeground: '#737373',
+          },
+          radii: {
+            none: '0',
+            sm: '0.125rem',
+            md: '0.375rem',
+            lg: '0.75rem',
+            xl: '1.5rem',
+            full: '9999px',
+          },
+        },
+        navigation: {
+          headerComponent: () => null,
+          footerComponent: () => null,
+        },
+        skipToMainContentLabelKey: SKIP_KEY,
+      }}
+    >
+      {ui}
+    </WebsiteRuntimeContextProvider>,
+  );
+}
+
+describe('WebsiteInternalLink', () => {
+  describe('default-locale page (un-prefixed routing)', () => {
+    it('renders the routePath verbatim when locale === defaultLocale', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="/pricing">Pricing</WebsiteInternalLink>,
+        { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('/pricing');
+    });
+
+    it('renders "/" verbatim for the default-locale root', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="/">Home</WebsiteInternalLink>,
+        { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('/');
+    });
+  });
+
+  describe('non-default-locale page (prefixed routing)', () => {
+    it('prefixes /<locale> on FR pages', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="/pricing">Pricing</WebsiteInternalLink>,
+        { locale: AvailableLanguage.FR, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('/fr/pricing');
+    });
+
+    it('collapses root to /<locale> (NOT /<locale>/)', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="/">Home</WebsiteInternalLink>,
+        { locale: AvailableLanguage.FR, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('/fr');
+    });
+  });
+
+  describe('special-case URLs', () => {
+    it('passes anchor-only links through verbatim', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="#features">Features</WebsiteInternalLink>,
+        { locale: AvailableLanguage.FR, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('#features');
+    });
+
+    it('passes mailto: through verbatim', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="mailto:hi@wildo.ai">Email</WebsiteInternalLink>,
+        { locale: AvailableLanguage.FR, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('mailto:hi@wildo.ai');
+    });
+
+    it('passes tel: through verbatim', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink routePath="tel:+1234567890">Call</WebsiteInternalLink>,
+        { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+      );
+      expect(container.querySelector('a')?.getAttribute('href')).toBe('tel:+1234567890');
+    });
+  });
+
+  describe('misuse guards', () => {
+    it('throws when routePath does not start with / and is not an anchor or scheme URL', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(() =>
+        renderWithRuntime(
+          <WebsiteInternalLink routePath="pricing">Pricing</WebsiteInternalLink>,
+          { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+        ),
+      ).toThrow(/must start with/i);
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('mentions external={true} (not bare external) in misuse error — Phase 6 fix L-Κ', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      let caught: Error | null = null;
+      try {
+        renderWithRuntime(
+          <WebsiteInternalLink routePath="pricing">Pricing</WebsiteInternalLink>,
+          { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+        );
+      } catch (e) {
+        caught = e as Error;
+      }
+      expect(caught?.message).toMatch(/external=\{true\}/);
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('throws when routePath begins with the active locale (double-prefix guard) — Phase 6 fix M-Ζ', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(() =>
+        renderWithRuntime(
+          <WebsiteInternalLink routePath="/fr/pricing">Pricing</WebsiteInternalLink>,
+          { locale: AvailableLanguage.FR, defaultLocale: AvailableLanguage.EN },
+        ),
+      ).toThrow(/locale segment/i);
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('throws when routePath begins with another known locale (cross-locale leak guard)', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(() =>
+        renderWithRuntime(
+          <WebsiteInternalLink routePath="/es/pricing">Pricing</WebsiteInternalLink>,
+          { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+        ),
+      ).toThrow(/locale segment/i);
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('throws when used outside <WebsiteRuntimeContextProvider>', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(() =>
+        render(<WebsiteInternalLink routePath="/pricing">Pricing</WebsiteInternalLink>),
+      ).toThrow(/WebsiteRuntimeContextProvider/);
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('attribute forwarding', () => {
+    it('forwards className, id, ariaLabel to the rendered anchor', () => {
+      const { container } = renderWithRuntime(
+        <WebsiteInternalLink
+          routePath="/contact"
+          className="wt-link"
+          id="contact-link"
+          ariaLabel="Open contact page"
+        >
+          Contact
+        </WebsiteInternalLink>,
+        { locale: AvailableLanguage.EN, defaultLocale: AvailableLanguage.EN },
+      );
+      const a = container.querySelector('a');
+      expect(a?.getAttribute('class')).toBe('wt-link');
+      expect(a?.getAttribute('id')).toBe('contact-link');
+      expect(a?.getAttribute('aria-label')).toBe('Open contact page');
+      expect(a?.getAttribute('target')).toBeNull();
+      expect(a?.getAttribute('rel')).toBeNull();
+    });
+  });
+});

package/src/components/low-level/__tests__/primitives.test.tsx

@@ -0,0 +1,141 @@
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+import {
+  WebsiteHeading,
+  WebsiteHeadingVariant,
+} from '../WebsiteHeading';
+import { WebsiteText, WebsiteTextVariant } from '../WebsiteText';
+import { WebsiteLink } from '../WebsiteLink';
+import {
+  WebsiteButton,
+  WebsiteButtonVariant,
+  WebsiteButtonSize,
+} from '../WebsiteButton';
+import { WebsiteImage } from '../WebsiteImage';
+
+describe('WebsiteHeading', () => {
+  it('renders the correct heading tag for the supplied level', () => {
+    const { container } = render(
+      <WebsiteHeading level={2} variant={WebsiteHeadingVariant.DISPLAY}>
+        Title
+      </WebsiteHeading>,
+    );
+    const h2 = container.querySelector('h2');
+    expect(h2).not.toBeNull();
+    expect(h2?.getAttribute('data-website-primitive')).toBe('heading');
+    expect(h2?.getAttribute('data-website-heading-variant')).toBe('display');
+  });
+
+  it('defaults variant to HEADLINE', () => {
+    const { container } = render(<WebsiteHeading level={1}>Title</WebsiteHeading>);
+    expect(
+      container.querySelector('h1')?.getAttribute('data-website-heading-variant'),
+    ).toBe('headline');
+  });
+});
+
+describe('WebsiteText', () => {
+  it('defaults to <p> with body variant', () => {
+    const { container } = render(<WebsiteText>Body copy</WebsiteText>);
+    const p = container.querySelector('p');
+    expect(p).not.toBeNull();
+    expect(p?.getAttribute('data-website-text-variant')).toBe('body');
+  });
+
+  it('honors as= and variant=', () => {
+    const { container } = render(
+      <WebsiteText as="span" variant={WebsiteTextVariant.LEAD}>
+        Lead
+      </WebsiteText>,
+    );
+    const span = container.querySelector('span');
+    expect(span).not.toBeNull();
+    expect(span?.getAttribute('data-website-text-variant')).toBe('lead');
+  });
+});
+
+describe('WebsiteLink', () => {
+  it('renders an internal anchor by default', () => {
+    const { container } = render(<WebsiteLink href="/pricing">Pricing</WebsiteLink>);
+    const a = container.querySelector('a');
+    expect(a?.getAttribute('href')).toBe('/pricing');
+    expect(a?.getAttribute('target')).toBeNull();
+    expect(a?.getAttribute('rel')).toBeNull();
+  });
+
+  it('applies external link safety attributes when external=true', () => {
+    const { container } = render(
+      <WebsiteLink href="https://wildo.ai" external>
+        Wildo
+      </WebsiteLink>,
+    );
+    const a = container.querySelector('a');
+    expect(a?.getAttribute('target')).toBe('_blank');
+    expect(a?.getAttribute('rel')).toBe('noopener noreferrer');
+  });
+});
+
+describe('WebsiteButton', () => {
+  it('renders an anchor when href is supplied', () => {
+    const { container } = render(
+      <WebsiteButton href="/signup" variant={WebsiteButtonVariant.PRIMARY}>
+        Sign up
+      </WebsiteButton>,
+    );
+    expect(container.querySelector('a')?.getAttribute('href')).toBe('/signup');
+    const inner = container.querySelector('[data-website-primitive="button"]');
+    expect(inner?.getAttribute('data-website-button-mode')).toBe('link');
+  });
+
+  it('renders a real <button> when href is omitted', () => {
+    const { container } = render(
+      <WebsiteButton type="submit" size={WebsiteButtonSize.LG}>
+        Submit
+      </WebsiteButton>,
+    );
+    const btn = container.querySelector('button');
+    expect(btn).not.toBeNull();
+    expect(btn?.getAttribute('type')).toBe('submit');
+    expect(btn?.getAttribute('data-website-button-size')).toBe('lg');
+    expect(btn?.getAttribute('data-website-button-mode')).toBe('button');
+  });
+});
+
+describe('WebsiteImage', () => {
+  it('renders <img> with required dimensions + lazy/async defaults', () => {
+    const { container } = render(
+      <WebsiteImage
+        src="/hero.png"
+        alt="Hero"
+        width={1200}
+        height={630}
+      />,
+    );
+    const img = container.querySelector('img');
+    expect(img?.getAttribute('src')).toBe('/hero.png');
+    expect(img?.getAttribute('alt')).toBe('Hero');
+    expect(img?.getAttribute('width')).toBe('1200');
+    expect(img?.getAttribute('height')).toBe('630');
+    expect(img?.getAttribute('loading')).toBe('lazy');
+    expect(img?.getAttribute('decoding')).toBe('async');
+  });
+
+  it('honors loading=eager / decoding=sync overrides for above-the-fold imagery', () => {
+    const { container } = render(
+      <WebsiteImage
+        src="/hero.png"
+        alt="Hero"
+        width={1200}
+        height={630}
+        loading="eager"
+        decoding="sync"
+      />,
+    );
+    const img = container.querySelector('img');
+    expect(img?.getAttribute('loading')).toBe('eager');
+    expect(img?.getAttribute('decoding')).toBe('sync');
+  });
+});

package/src/config/__tests__/define-website-config.test.ts

@@ -0,0 +1,231 @@
+/**
+ * `defineWebsiteConfig` parse-time contract.
+ *
+ * Pins the invariants the per-service `wildo.website.config.ts` flow
+ * depends on (Step 7.5 refactor — `saas-website-slice.md`, mirrors
+ * `saas-technical-doc.md` Step 7.5). This is the framework-owned mirror
+ * of the previous root-level `WildoSaasConfig.marketingWebsite?` test
+ * surface that lived in `platform-config-lib`. The contract changed
+ * in two places and stayed the same everywhere else:
+ *
+ *   - `enabled` REMOVED — file presence under a `frontendType: STATIC_WEBSITE`
+ *     service IS the enable signal. A previously-required
+ *     `enabled: true` author would now be rejected by the strict-object
+ *     schema as an unknown key.
+ *   - The schema moved to the engine package (`@wildo-ai/saas-website`)
+ *     so its evolution does not require a parallel
+ *     `platform-config-lib` edit; the warning prefix is now
+ *     `[wildo-website-config]` (was `[wildo-saas-config]` for the
+ *     root-level block).
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest';
+import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+import { defineWebsiteConfig } from '../define-website-config';
+
+// `MockInstance` takes the ARGS TUPLE and the return type, not the function type — the same
+// arity trap as `vi.fn<…>`. `process.stderr.write` is overloaded, so `Parameters` resolves to
+// its last signature, which is what the spy records.
+let stderrSpy: MockInstance<
+  Parameters<typeof process.stderr.write>,
+  ReturnType<typeof process.stderr.write>
+>;
+
+beforeEach(() => {
+  stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((() => true) as never);
+});
+
+afterEach(() => {
+  stderrSpy.mockRestore();
+});
+
+function getEmittedRawMessages(): string[] {
+  const out: string[] = [];
+  for (const call of stderrSpy.mock.calls) {
+    const message = call[0];
+    if (typeof message === 'string') out.push(message);
+  }
+  return out;
+}
+
+const MINIMAL_VALID_INPUT = {
+  publicOrigin: 'https://wonder-todos.example.com',
+  appOrigin: 'https://app.wonder-todos.example.com',
+  defaultLocale: AvailableLanguage.EN,
+  locales: [
+    { locale: AvailableLanguage.EN, path: 'en' },
+    { locale: AvailableLanguage.FR, path: 'fr' },
+  ],
+};
+
+describe('defineWebsiteConfig — schema contract', () => {
+  it('parses a full valid config', () => {
+    const parsed = defineWebsiteConfig(MINIMAL_VALID_INPUT);
+    expect(parsed).toEqual(MINIMAL_VALID_INPUT);
+  });
+
+  it('accepts an authored csp block for the website-local sync pipeline', () => {
+    const parsed = defineWebsiteConfig({
+      ...MINIMAL_VALID_INPUT,
+      csp: {
+        enabled: true,
+        reportOnly: true,
+      },
+    });
+
+    expect(parsed.csp).toMatchObject({
+      enabled: true,
+      reportOnly: true,
+    });
+  });
+
+  it('rejects an unknown top-level key (strictObject fail-closed)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        ...MINIMAL_VALID_INPUT,
+        // @ts-expect-error — typoed `publicOrigins` (plural)
+        publicOrigins: 'https://example.com',
+      }),
+    ).toThrow(/Unrecognized key.*publicOrigins/);
+  });
+
+  it('rejects the legacy `enabled` field (Step 7.5 — file presence is the enable signal)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        ...MINIMAL_VALID_INPUT,
+        // @ts-expect-error — `enabled` was removed in Step 7.5; authoring
+        // it now is a strict-object error so silently-stale configs
+        // surface during the migration.
+        enabled: true,
+      }),
+    ).toThrow(/Unrecognized key.*enabled/);
+  });
+
+  it('rejects a non-URL publicOrigin (z.url fail-closed)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        ...MINIMAL_VALID_INPUT,
+        publicOrigin: 'not-a-url',
+      }),
+    ).toThrow(/publicOrigin/);
+  });
+
+  it('rejects a publicOrigin with a trailing slash (canonical-URL composition guard, post seam-collapse)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        ...MINIMAL_VALID_INPUT,
+        publicOrigin: 'https://wonder-todos.example.com/',
+      }),
+    ).toThrow(/publicOrigin.*trailing/i);
+  });
+
+  it('rejects a non-URL appOrigin (z.url fail-closed)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        ...MINIMAL_VALID_INPUT,
+        appOrigin: 'not-a-url',
+      }),
+    ).toThrow(/appOrigin/);
+  });
+
+  it('rejects an unknown AvailableLanguage in defaultLocale (typo fails at parse time)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        ...MINIMAL_VALID_INPUT,
+        // @ts-expect-error — `xx` is not a valid AvailableLanguage value
+        defaultLocale: 'xx',
+      }),
+    ).toThrow(/defaultLocale/);
+  });
+
+  it('rejects defaultLocale that is not declared in `locales` (cross-field invariant)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        publicOrigin: 'https://example.com',
+        appOrigin: 'https://app.example.com',
+        defaultLocale: AvailableLanguage.FR,
+        locales: [{ locale: AvailableLanguage.EN, path: 'en' }],
+      }),
+    ).toThrow(/defaultLocale.*not declared/);
+  });
+
+  it('rejects an empty locales array (must build at least one locale)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        publicOrigin: 'https://example.com',
+        appOrigin: 'https://app.example.com',
+        defaultLocale: AvailableLanguage.EN,
+        locales: [],
+      }),
+    ).toThrow(/locales/);
+  });
+
+  it('rejects a locale path with uppercase characters (URL-segment regex fail-closed)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        publicOrigin: 'https://example.com',
+        appOrigin: 'https://app.example.com',
+        defaultLocale: AvailableLanguage.EN,
+        locales: [{ locale: AvailableLanguage.EN, path: 'EN' }],
+      }),
+    ).toThrow(/locale path/);
+  });
+
+  it('rejects duplicate locale paths in the locales array (sitemap-collision guard)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        publicOrigin: 'https://example.com',
+        appOrigin: 'https://app.example.com',
+        defaultLocale: AvailableLanguage.EN,
+        locales: [
+          { locale: AvailableLanguage.EN, path: 'shared' },
+          { locale: AvailableLanguage.FR, path: 'shared' },
+        ],
+      }),
+    ).toThrow(/Locale path 'shared' is declared by both/);
+  });
+
+  it('rejects duplicate locales in the locales array (hreflang-duplication guard)', () => {
+    expect(() =>
+      defineWebsiteConfig({
+        publicOrigin: 'https://example.com',
+        appOrigin: 'https://app.example.com',
+        defaultLocale: AvailableLanguage.EN,
+        locales: [
+          { locale: AvailableLanguage.EN, path: 'en' },
+          { locale: AvailableLanguage.EN, path: 'en-us' },
+        ],
+      }),
+    ).toThrow(/Locale '.*' is declared twice/);
+  });
+});
+
+describe('defineWebsiteConfig — @unimplemented warnings', () => {
+  /**
+   * The `@unimplemented` warner has ZERO branches today, NOT
+   * because every authored field is wired to a runtime consumer
+   * — `appOrigin` still has no runtime consumer (the
+   * marketing → app handoff link surface that will read it does
+   * not exist yet, see the schema file header) — but because the
+   * only OPTIONAL field that exists today (`csp?`) is already wired,
+   * and firing on every Astro build for a required field would drown
+   * the dev console.
+   * After the seam-collapse (`saas-website-seam-collapse.md` —
+   * SHIPPED), `publicOrigin`, `defaultLocale`, and `locales` are
+   * each consumed by at least one engine helper via
+   * `WebsiteSiteContext`, so they are no longer candidates for
+   * the warner either. See `define-website-config.ts >
+   * emitUnimplementedRuntimeWarnings` for the full rationale +
+   * the recipe for adding the first branch the day a `seo?` /
+   * `structuredData?` optional field lands.
+   *
+   * This test pins the no-warnings contract so the moment a
+   * branch is added (without flipping this expectation in the
+   * same commit) it surfaces as a test failure rather than a
+   * silent stderr noise on every build.
+   */
+  it('emits NO warnings (the optional website csp field is fully wired — warner still has zero branches)', () => {
+    defineWebsiteConfig(MINIMAL_VALID_INPUT);
+    expect(getEmittedRawMessages()).toEqual([]);
+  });
+});