@akinon/pz-theme 2.0.29-beta.0 → 2.0.29

package/CHANGELOG.md

@@ -1,11 +1,11 @@
 # @akinon/pz-theme
 
-## 2.0.29-beta.0
+## 2.0.29
 
 ### Patch Changes
 
-- Updated dependencies [cbbbfd75]
-  - @akinon/next@2.0.29-beta.0
+- fe2f23e: ZERO-4584: Add jest (ts-jest + jsdom) test infrastructure to pz-theme and core unit/parity tests for the theme render engine (responsive/color/opacity resolution, visibility rules, publish window, iterator binding/price escaping, block/section registry parity).
+  - @akinon/next@2.0.29
 
 ## 2.0.28
 

package/jest/style-mock.js

@@ -0,0 +1,2 @@
+// Stub for side-effect CSS imports during tests.
+module.exports = {};

package/jest.config.js

@@ -0,0 +1,40 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  // jsdom so the same config serves both pure-function tests and future
+  // React component (RTL) tests without reconfiguration.
+  testEnvironment: 'jsdom',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.test.ts', '**/*.test.tsx'],
+  // Stub side-effect CSS imports (e.g. react-multi-carousel styles) so that
+  // importing a component never fails on a missing CSS transform.
+  moduleNameMapper: {
+    '\\.(css|less|scss|sass)$': '<rootDir>/jest/style-mock.js'
+  },
+  transform: {
+    '^.+\\.(ts|tsx)$': [
+      'ts-jest',
+      {
+        tsconfig: {
+          // Transpile-only: avoids whole-program type-checking (pz-theme has
+          // no tsconfig and relies on consumer transpilation) while still
+          // eliding type-only imports such as `import { Block }`.
+          isolatedModules: true,
+          jsx: 'react-jsx',
+          esModuleInterop: true,
+          allowSyntheticDefaultImports: true,
+          module: 'commonjs',
+          target: 'es2020',
+          lib: ['es2020', 'dom', 'dom.iterable'],
+          moduleResolution: 'node',
+          resolveJsonModule: true,
+          skipLibCheck: true
+        }
+      }
+    ]
+  },
+  // ESM-only deps that must be transformed if a test pulls them in.
+  transformIgnorePatterns: [
+    'node_modules/(?!(lottie-web|react-multi-carousel|swiper|ssr-window|dom7|@akinon)/)'
+  ]
+};

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@akinon/pz-theme",
   "description": "Theme package for Project Zero Next — ThemePlaceholder system and theme editor infrastructure",
-  "version": "2.0.29-beta.0",
+  "version": "2.0.29",
   "license": "MIT",
   "main": "src/index.ts",
+  "scripts": {
+    "test": "jest"
+  },
   "peerDependencies": {
-    "@akinon/next": "2.0.29-beta.0",
+    "@akinon/next": "2.0.29",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
@@ -15,13 +18,17 @@
     "tailwind-merge": "^2.5.4"
   },
   "devDependencies": {
-    "@akinon/next": "2.0.29-beta.0",
+    "@akinon/next": "2.0.29",
+    "@types/jest": "29.5.14",
     "@types/node": "^18.7.8",
     "@types/react": "^18.0.17",
     "@types/react-dom": "^18.0.6",
+    "jest": "29.7.0",
+    "jest-environment-jsdom": "29.7.0",
     "prettier": "^3.0.3",
     "react": "19.2.5",
     "react-dom": "19.2.5",
+    "ts-jest": "29.2.6",
     "typescript": "^5.2.2"
   }
 }

package/src/__tests__/registry-parity.test.ts

@@ -0,0 +1,95 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Tier 2 — in-package registry lock test.
+ *
+ * Catches the most common silent render bug: a renderer that is never
+ * `register()`-ed, a typo'd type key (e.g. `stat-counter` vs `stats-counter`),
+ * an accidental removal, or a duplicate. The registries are NOT imported at
+ * runtime here on purpose — importing them transitively pulls the whole
+ * component tree (@akinon/next data hooks, react-multi-carousel, `settings`,
+ * yup, …). Instead we parse the `register('type', …)` calls from source.
+ *
+ * NOTE: this does NOT catch editor<->render drift (a type that exists in the
+ * pz-dynamic-widget BlockType/SectionType enum but has no renderer here). That
+ * needs a committed cross-repo manifest and is a separate follow-up.
+ */
+
+const readSource = (relPath: string): string =>
+  fs.readFileSync(path.resolve(__dirname, relPath), 'utf8');
+
+const extractRegisteredTypes = (source: string): string[] => {
+  const matches = source.matchAll(/\.register\(\s*['"]([^'"]+)['"]/g);
+  return Array.from(matches, (m) => m[1]);
+};
+
+const EXPECTED_BLOCK_TYPES = [
+  'accordion',
+  'button',
+  'counter',
+  'divider',
+  'embed',
+  'group',
+  'hotspot',
+  'icon',
+  'image',
+  'image-gallery',
+  'input',
+  'link',
+  'lottie',
+  'map',
+  'slider',
+  'tab',
+  'text',
+  'video'
+];
+
+const EXPECTED_SECTION_TYPES = [
+  'before-after',
+  'contact-form',
+  'countdown-banner',
+  'coupon-banner',
+  'divider',
+  'featured-product-spotlight',
+  'find-in-store',
+  'flash-deals-slider',
+  'hover-showcase',
+  'image-hotspot',
+  'installment-options',
+  'notification-banner',
+  'order-tracking-lookup',
+  'posts-slider',
+  'pre-order-launch-banner',
+  'shipping-threshold-progress',
+  'stats-counter',
+  'tabs'
+];
+
+describe('block renderer registry parity', () => {
+  const registered = extractRegisteredTypes(
+    readSource('../blocks/block-renderer-registry.tsx')
+  );
+
+  it('registers exactly the approved set of block types', () => {
+    expect([...registered].sort()).toEqual([...EXPECTED_BLOCK_TYPES].sort());
+  });
+
+  it('has no duplicate registrations', () => {
+    expect(new Set(registered).size).toBe(registered.length);
+  });
+});
+
+describe('section renderer registry parity', () => {
+  const registered = extractRegisteredTypes(
+    readSource('../sections/section-renderer-registry.tsx')
+  );
+
+  it('registers exactly the approved set of section types', () => {
+    expect([...registered].sort()).toEqual([...EXPECTED_SECTION_TYPES].sort());
+  });
+
+  it('has no duplicate registrations', () => {
+    expect(new Set(registered).size).toBe(registered.length);
+  });
+});

package/src/utils/iterator-binding-price.test.ts

@@ -0,0 +1,171 @@
+import { buildIteratorBlock, resolveBlockBindings } from './iterator-utils';
+
+// Minimal block factory — pz-theme tests run transpile-only (isolatedModules),
+// so partial shapes are fine and keep the cases readable.
+const textBlock = (props: Record<string, unknown>, id = 'b') =>
+  ({
+    id,
+    type: 'text',
+    label: id,
+    value: '',
+    properties: {},
+    styles: {},
+    order: 0,
+    hidden: false,
+    ...props
+  } as any);
+
+describe('resolveBlockBindings (page-context, non-iterator)', () => {
+  const dataSource = { type: 'page-context' } as any;
+
+  it('resolves an array-index path (products[1].name)', () => {
+    const result = resolveBlockBindings({
+      block: textBlock({ properties: { dataBinding: 'products[1].name' } }),
+      sectionDataSource: dataSource,
+      pageContext: { products: [{ name: 'A' }, { name: 'B' }] }
+    });
+    expect(result.value).toBe('B');
+  });
+
+  it('leaves the value untouched when the path does not resolve', () => {
+    const result = resolveBlockBindings({
+      block: textBlock({
+        value: 'fallback',
+        properties: { dataBinding: 'products[5].name' }
+      }),
+      sectionDataSource: dataSource,
+      pageContext: { products: [{ name: 'A' }] }
+    });
+    expect(result.value).toBe('fallback');
+  });
+
+  it('writes a link binding to properties.href (default target for links)', () => {
+    const result = resolveBlockBindings({
+      block: {
+        id: 'l',
+        type: 'link',
+        label: 'l',
+        properties: { dataBinding: 'products[0].url' },
+        styles: {},
+        order: 0,
+        hidden: false
+      } as any,
+      sectionDataSource: dataSource,
+      pageContext: { products: [{ url: '/p/1' }] }
+    });
+    expect(result.properties?.href).toBe('/p/1');
+  });
+
+  it('does NOT resolve item.* paths (those belong to the iterator path)', () => {
+    const result = resolveBlockBindings({
+      block: textBlock({
+        value: 'keep',
+        properties: { dataBinding: 'item.title' }
+      }),
+      sectionDataSource: dataSource,
+      pageContext: { title: 'ignored' }
+    });
+    expect(result.value).toBe('keep');
+  });
+});
+
+describe('buildIteratorBlock — price formatting', () => {
+  const iterator = (template: any) =>
+    ({
+      id: 'iter',
+      type: 'group',
+      label: 'iter',
+      isIterator: true,
+      properties: {},
+      styles: {},
+      order: 0,
+      hidden: false,
+      blocks: [template]
+    } as any);
+
+  const staticSource = (items: unknown[]) =>
+    ({ type: 'static', details: { static: { data: items } } } as any);
+
+  it('renders a discounted price (retail struck-through + bold current)', () => {
+    const result = buildIteratorBlock({
+      iteratorBlock: iterator(
+        textBlock({ properties: { dataBinding: 'item.active_price.price' } }, 'price')
+      ),
+      sectionDataSource: staticSource([
+        {
+          active_price: {
+            price: '899.99',
+            retail_price: '1299.99',
+            currency_type: 'TRY'
+          }
+        }
+      ]),
+      isDesigner: false
+    });
+
+    const html = result.blocks?.[0].value as string;
+    expect(html).toContain('text-decoration:line-through');
+    expect(html).toContain('font-weight:600');
+    // tr-TR formatting + TRY normalized to TL.
+    expect(html).toContain('1.299,99 TL');
+    expect(html).toContain('899,99 TL');
+    // retail must appear before current.
+    expect(html.indexOf('1.299,99')).toBeLessThan(html.indexOf('899,99'));
+  });
+
+  it('renders a plain price when there is no higher retail price', () => {
+    const result = buildIteratorBlock({
+      iteratorBlock: iterator(
+        textBlock({ properties: { dataBinding: 'item.price' } }, 'price')
+      ),
+      sectionDataSource: staticSource([{ price: '49.9', currency_type: 'TL' }]),
+      isDesigner: false
+    });
+
+    const html = result.blocks?.[0].value as string;
+    expect(html).toContain('49,90 TL');
+    expect(html).not.toContain('line-through');
+  });
+
+  it('escapes HTML in price/currency (no raw tags leak into the markup)', () => {
+    const result = buildIteratorBlock({
+      iteratorBlock: iterator(
+        textBlock({ properties: { dataBinding: 'item.active_price.price' } }, 'price')
+      ),
+      sectionDataSource: staticSource([
+        {
+          active_price: {
+            price: '10',
+            currency_type: '<img src=x onerror=alert(1)>'
+          }
+        }
+      ]),
+      isDesigner: false
+    });
+
+    const html = result.blocks?.[0].value as string;
+    expect(html).not.toMatch(/<img/i);
+    expect(html).toContain('&lt;');
+  });
+
+  it('produces one clone per item', () => {
+    const result = buildIteratorBlock({
+      iteratorBlock: iterator(
+        textBlock({ properties: { dataBinding: 'item.title' } }, 'title')
+      ),
+      sectionDataSource: staticSource([
+        { title: 'One' },
+        { title: 'Two' },
+        { title: 'Three' }
+      ]),
+      isDesigner: false
+    });
+
+    expect(result.blocks).toHaveLength(3);
+    expect(result.blocks?.map((b: any) => b.value)).toEqual([
+      'One',
+      'Two',
+      'Three'
+    ]);
+  });
+});

package/src/utils/publish-window.test.ts

@@ -0,0 +1,96 @@
+import {
+  getPublishWindowStatus,
+  isPublishWindowVisible,
+  normalizePublishWindowValue
+} from './publish-window';
+
+const NOW = new Date('2026-06-25T12:00:00.000Z');
+
+describe('getPublishWindowStatus', () => {
+  it('is inactive when disabled or missing', () => {
+    expect(getPublishWindowStatus(undefined, NOW)).toBe('inactive');
+    expect(getPublishWindowStatus({ enabled: false }, NOW)).toBe('inactive');
+  });
+
+  it('is active when enabled with no bounds', () => {
+    expect(getPublishWindowStatus({ enabled: true }, NOW)).toBe('active');
+  });
+
+  it('is scheduled before the start and expired after the end', () => {
+    expect(
+      getPublishWindowStatus(
+        { enabled: true, startAt: '2026-06-26T00:00:00.000Z' },
+        NOW
+      )
+    ).toBe('scheduled');
+    expect(
+      getPublishWindowStatus(
+        { enabled: true, endAt: '2026-06-24T00:00:00.000Z' },
+        NOW
+      )
+    ).toBe('expired');
+  });
+
+  it('is active inside the window', () => {
+    expect(
+      getPublishWindowStatus(
+        {
+          enabled: true,
+          startAt: '2026-06-24T00:00:00.000Z',
+          endAt: '2026-06-26T00:00:00.000Z'
+        },
+        NOW
+      )
+    ).toBe('active');
+  });
+
+  it('fails open (active) on an unparseable date string', () => {
+    expect(
+      getPublishWindowStatus({ enabled: true, startAt: 'not-a-date' }, NOW)
+    ).toBe('active');
+  });
+
+  it('reads a responsive-nested publish window value', () => {
+    expect(
+      getPublishWindowStatus(
+        { desktop: { enabled: true, startAt: '2026-06-26T00:00:00.000Z' } },
+        NOW
+      )
+    ).toBe('scheduled');
+  });
+});
+
+describe('isPublishWindowVisible', () => {
+  it('is visible only for inactive and active statuses', () => {
+    expect(isPublishWindowVisible({ enabled: false }, NOW)).toBe(true);
+    expect(isPublishWindowVisible({ enabled: true }, NOW)).toBe(true);
+    expect(
+      isPublishWindowVisible(
+        { enabled: true, startAt: '2026-06-26T00:00:00.000Z' },
+        NOW
+      )
+    ).toBe(false);
+    expect(
+      isPublishWindowVisible(
+        { enabled: true, endAt: '2026-06-24T00:00:00.000Z' },
+        NOW
+      )
+    ).toBe(false);
+  });
+});
+
+describe('normalizePublishWindowValue', () => {
+  it('normalizes a flat value', () => {
+    expect(
+      normalizePublishWindowValue({ enabled: true, startAt: '2026-01-01' })
+    ).toEqual({ enabled: true, startAt: '2026-01-01', endAt: '' });
+  });
+
+  it('returns a disabled default for non-window shapes', () => {
+    expect(normalizePublishWindowValue(null)).toEqual({
+      enabled: false,
+      startAt: '',
+      endAt: ''
+    });
+  });
+});

package/src/utils/style-resolution.test.ts

@@ -0,0 +1,138 @@
+import {
+  getResponsiveValue,
+  colorToRgba,
+  applyAlphaToColor,
+  clampAlpha,
+  resolveThemeCssVariables
+} from './index';
+
+describe('getResponsiveValue', () => {
+  it('returns the value for the active breakpoint', () => {
+    expect(
+      getResponsiveValue({ desktop: '24px', mobile: '16px' }, 'mobile')
+    ).toBe('16px');
+    expect(
+      getResponsiveValue({ desktop: '24px', mobile: '16px' }, 'desktop')
+    ).toBe('24px');
+  });
+
+  it('falls back to desktop when the requested breakpoint is missing (desktop-first inheritance)', () => {
+    expect(getResponsiveValue({ desktop: '24px' }, 'mobile')).toBe('24px');
+  });
+
+  it('a mobile-only value is NOT rendered on desktop (known edge case)', () => {
+    // No desktop base => nothing to inherit, returns the fallback.
+    expect(getResponsiveValue({ mobile: '16px' }, 'desktop')).toBe('');
+    expect(getResponsiveValue({ mobile: '16px' }, 'mobile')).toBe('16px');
+  });
+
+  it('passes through plain (non-responsive) values for every breakpoint', () => {
+    expect(getResponsiveValue('24px', 'mobile')).toBe('24px');
+    expect(getResponsiveValue(0, 'mobile')).toBe(0);
+    expect(getResponsiveValue(false, 'desktop')).toBe(false);
+  });
+
+  it('returns the fallback for empty / null / undefined', () => {
+    expect(getResponsiveValue(undefined, 'desktop', 'normal')).toBe('normal');
+    expect(getResponsiveValue(null, 'desktop', 'normal')).toBe('normal');
+    expect(getResponsiveValue('', 'desktop', 'normal')).toBe('normal');
+  });
+
+  it('treats an array as an (empty) responsive object and returns the fallback', () => {
+    // Documents that arrays are mis-handled by the typeof-object branch.
+    expect(getResponsiveValue([1, 2, 3], 'desktop', 'fb')).toBe('fb');
+  });
+});
+
+describe('colorToRgba', () => {
+  it('parses 6-digit and 3-digit hex', () => {
+    expect(colorToRgba('#e63946', 0.9)).toBe('rgba(230, 57, 70, 0.9)');
+    expect(colorToRgba('#abc', 1)).toBe('rgba(170, 187, 204, 1)');
+  });
+
+  it('accepts hex without a leading #', () => {
+    expect(colorToRgba('e63946', 0.5)).toBe('rgba(230, 57, 70, 0.5)');
+  });
+
+  it('parses comma and space rgb()/rgba()', () => {
+    expect(colorToRgba('rgb(12, 34, 56)', 0.5)).toBe('rgba(12, 34, 56, 0.5)');
+    expect(colorToRgba('rgb(12 34 56)', 0.5)).toBe('rgba(12, 34, 56, 0.5)');
+  });
+
+  it('returns null for formats it cannot parse (named, var, 8-digit hex, hsl)', () => {
+    // These return null -> the caller silently drops the alpha. Locking the
+    // current behavior so a future change here is a conscious decision.
+    expect(colorToRgba('red', 0.5)).toBeNull();
+    expect(colorToRgba('var(--theme-primary)', 0.5)).toBeNull();
+    expect(colorToRgba('#11223344', 0.5)).toBeNull();
+    expect(colorToRgba('hsl(0, 100%, 50%)', 0.5)).toBeNull();
+  });
+});
+
+describe('applyAlphaToColor', () => {
+  it('returns transparent at alpha 0 and the raw color at alpha >= 1', () => {
+    expect(applyAlphaToColor('#e63946', 0)).toBe('transparent');
+    expect(applyAlphaToColor('#e63946', 1)).toBe('#e63946');
+  });
+
+  it('produces rgba for parseable colors', () => {
+    expect(applyAlphaToColor('#e63946', 0.9)).toBe('rgba(230, 57, 70, 0.9)');
+  });
+
+  it('falls back to color-mix for named / var() colors (unlike the inline color path)', () => {
+    expect(applyAlphaToColor('var(--theme-secondary)', 0.5)).toBe(
+      'color-mix(in srgb, var(--theme-secondary) 50%, transparent)'
+    );
+    expect(applyAlphaToColor('red', 0.5)).toBe(
+      'color-mix(in srgb, red 50%, transparent)'
+    );
+  });
+});
+
+describe('clampAlpha', () => {
+  it('converts percentage to a 0..1 alpha', () => {
+    expect(clampAlpha(50)).toBe(0.5);
+    expect(clampAlpha('50')).toBe(0.5);
+  });
+
+  it('uses the fallback for empty / null / undefined (default 100 => 1)', () => {
+    expect(clampAlpha('')).toBe(1);
+    expect(clampAlpha(undefined)).toBe(1);
+    expect(clampAlpha(null)).toBe(1);
+    expect(clampAlpha('', 0)).toBe(0);
+  });
+
+  it('clamps out-of-range values into 0..1', () => {
+    expect(clampAlpha(150)).toBe(1);
+    expect(clampAlpha(-10)).toBe(0);
+  });
+
+  it('returns null for non-numeric values (incl. "50%")', () => {
+    expect(clampAlpha('abc')).toBeNull();
+    expect(clampAlpha('50%')).toBeNull();
+  });
+});
+
+describe('resolveThemeCssVariables', () => {
+  it('resolves a mapped var() from theme settings', () => {
+    expect(
+      resolveThemeCssVariables('var(--theme-primary)', {
+        primaryColor: '#e63946'
+      })
+    ).toBe('#e63946');
+  });
+
+  it('uses the inline fallback when the var is unmapped/unresolved', () => {
+    expect(resolveThemeCssVariables('var(--whatever, #fff)', {})).toBe('#fff');
+  });
+
+  it('keeps the literal var() when nothing resolves it', () => {
+    expect(resolveThemeCssVariables('var(--theme-primary)', {})).toBe(
+      'var(--theme-primary)'
+    );
+  });
+
+  it('returns non-var strings unchanged', () => {
+    expect(resolveThemeCssVariables('#ffffff', {})).toBe('#ffffff');
+  });
+});

package/src/utils/visibility-rules.test.ts

@@ -0,0 +1,155 @@
+import {
+  evaluateVisibilityRules,
+  VisibilityRuleContext
+} from './visibility-rules';
+
+const makeContext = (
+  overrides: Partial<VisibilityRuleContext> = {}
+): VisibilityRuleContext => ({
+  authState: 'guest',
+  breakpoint: 'desktop',
+  locale: 'tr',
+  currency: 'TRY',
+  pathname: '/',
+  searchParams: null,
+  ...overrides
+});
+
+describe('evaluateVisibilityRules', () => {
+  it('is visible when rules are missing or disabled', () => {
+    expect(evaluateVisibilityRules(undefined, makeContext())).toBe(true);
+    expect(evaluateVisibilityRules({ enabled: false }, makeContext())).toBe(
+      true
+    );
+  });
+
+  describe('authState', () => {
+    it('restricts to guest / authenticated', () => {
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, authState: 'guest' },
+          makeContext({ authState: 'guest' })
+        )
+      ).toBe(true);
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, authState: 'guest' },
+          makeContext({ authState: 'authenticated' })
+        )
+      ).toBe(false);
+    });
+
+    it('hides auth-restricted elements while auth is still loading (FOUC guard)', () => {
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, authState: 'authenticated' },
+          makeContext({ authState: 'loading' })
+        )
+      ).toBe(false);
+    });
+  });
+
+  it('filters by allowedBreakpoints (empty list = no filter)', () => {
+    expect(
+      evaluateVisibilityRules(
+        { enabled: true, allowedBreakpoints: ['mobile'] },
+        makeContext({ breakpoint: 'desktop' })
+      )
+    ).toBe(false);
+    expect(
+      evaluateVisibilityRules(
+        { enabled: true, allowedBreakpoints: ['mobile'] },
+        makeContext({ breakpoint: 'mobile' })
+      )
+    ).toBe(true);
+  });
+
+  it('matches currencies case-insensitively (rule + context upper-cased)', () => {
+    expect(
+      evaluateVisibilityRules(
+        { enabled: true, allowedCurrencies: ['usd'] },
+        makeContext({ currency: 'USD' })
+      )
+    ).toBe(true);
+    expect(
+      evaluateVisibilityRules(
+        { enabled: true, allowedCurrencies: ['USD'] },
+        makeContext({ currency: 'eur' })
+      )
+    ).toBe(false);
+  });
+
+  describe('pathname matching', () => {
+    it('startsWith / equals / contains', () => {
+      expect(
+        evaluateVisibilityRules(
+          {
+            enabled: true,
+            pathnameMatchType: 'startsWith',
+            pathnameValue: '/account'
+          },
+          makeContext({ pathname: '/account/orders' })
+        )
+      ).toBe(true);
+      expect(
+        evaluateVisibilityRules(
+          {
+            enabled: true,
+            pathnameMatchType: 'startsWith',
+            pathnameValue: '/account'
+          },
+          makeContext({ pathname: '/cart' })
+        )
+      ).toBe(false);
+      expect(
+        evaluateVisibilityRules(
+          {
+            enabled: true,
+            pathnameMatchType: 'equals',
+            pathnameValue: '/x'
+          },
+          makeContext({ pathname: '/y' })
+        )
+      ).toBe(false);
+    });
+
+    it('fails closed when match type is set but the value is empty', () => {
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, pathnameMatchType: 'equals', pathnameValue: '' },
+          makeContext({ pathname: '/' })
+        )
+      ).toBe(false);
+    });
+  });
+
+  describe('query params', () => {
+    const searchParams = (map: Record<string, string>) => ({
+      get: (key: string) => (key in map ? map[key] : null)
+    });
+
+    it('requires the key to be present', () => {
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, queryParamKey: 'campaign' },
+          makeContext({ searchParams: searchParams({}) })
+        )
+      ).toBe(false);
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, queryParamKey: 'campaign' },
+          makeContext({ searchParams: searchParams({ campaign: 'x' }) })
+        )
+      ).toBe(true);
+    });
+
+    it('requires the value to match when provided', () => {
+      expect(
+        evaluateVisibilityRules(
+          { enabled: true, queryParamKey: 'campaign', queryParamValue: 'x' },
+          makeContext({ searchParams: searchParams({ campaign: 'y' }) })
+        )
+      ).toBe(false);
+    });
+  });
+});