@usequeek/theme-kit 0.1.22 → 0.1.24

package/tests/locale-switch.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  defaultStoreLocale,
-  localeHref,
-  normalizeStoreLocales,
-  resolveActiveLocale,
-  type StoreLocale,
-  type StoreLocaleInput,
-} from '../utils/locale-switch';
-
-function row(locale: string, extra: Partial<StoreLocaleInput> = {}): StoreLocaleInput {
-  return { locale, name: locale, native_name: locale, is_primary: false, ...extra };
-}
-
-/** English default, French and Simplified Chinese under prefixes. */
-const EN_DEFAULT = normalizeStoreLocales([
-  row('en', { name: 'English', native_name: 'English', is_primary: true, is_default: true, path_prefix: '' }),
-  row('fr', { name: 'French', native_name: 'Français', is_default: false, path_prefix: 'fr' }),
-  row('zh-CN', { name: 'Chinese', native_name: '简体中文', is_default: false, path_prefix: 'zh-cn' }),
-]);
-
-/** French default; English (the primary) is not the default, so it lives under /en. */
-const FR_DEFAULT = normalizeStoreLocales([
-  row('fr', { name: 'French', native_name: 'Français', is_default: true, path_prefix: '' }),
-  row('en', { name: 'English', native_name: 'English', is_primary: true, is_default: false, path_prefix: 'en' }),
-]);
-
-function pick(locales: StoreLocale[], code: string): StoreLocale {
-  const found = locales.find((l) => l.locale === code);
-  if (!found) throw new Error(`fixture has no ${code}`);
-  return found;
-}
-
-function href(
-  locales: StoreLocale[],
-  from: string,
-  to: string,
-  url: { pathname: string; search?: string; hash?: string; basePath?: string },
-): string {
-  return localeHref({ ...url, active: pick(locales, from), target: pick(locales, to) });
-}
-
-describe('localeHref', () => {
-  it('moves the default language to a prefix and back to the root', () => {
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/shop' })).toBe('/fr/shop');
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/fr/shop', basePath: '/fr' })).toBe('/shop');
-  });
-
-  it('keeps the root path at the root of each language', () => {
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/' })).toBe('/fr');
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/fr', basePath: '/fr' })).toBe('/');
-  });
-
-  it('puts English under /en when English is not the default', () => {
-    expect(href(FR_DEFAULT, 'fr', 'en', { pathname: '/shop' })).toBe('/en/shop');
-    expect(href(FR_DEFAULT, 'en', 'fr', { pathname: '/en/shop', basePath: '/en' })).toBe('/shop');
-  });
-
-  it('uses the lower-case code as the prefix (zh-CN -> /zh-cn)', () => {
-    expect(href(EN_DEFAULT, 'en', 'zh-CN', { pathname: '/products/mug' })).toBe('/zh-cn/products/mug');
-    expect(href(EN_DEFAULT, 'zh-CN', 'fr', { pathname: '/zh-cn/products/mug', basePath: '/zh-cn' })).toBe('/fr/products/mug');
-  });
-
-  it('switches directly between two prefixed languages', () => {
-    expect(href(EN_DEFAULT, 'fr', 'zh-CN', { pathname: '/fr/shop/all', basePath: '/fr' })).toBe('/zh-cn/shop/all');
-  });
-
-  it('keeps the query string and the hash', () => {
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/shop', search: '?sort=new&page=2', hash: '#reviews' })).toBe(
-      '/fr/shop?sort=new&page=2#reviews',
-    );
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/fr', basePath: '/fr', search: '?q=a', hash: '#top' })).toBe('/?q=a#top');
-  });
-
-  it('accepts a query string and hash without their leading marks, and ignores empty ones', () => {
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/shop', search: 'a=1', hash: 'x' })).toBe('/fr/shop?a=1#x');
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/shop', search: '?', hash: '#' })).toBe('/fr/shop');
-  });
-
-  it('keeps a trailing slash on a nested path', () => {
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/shop/' })).toBe('/fr/shop/');
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/fr/shop/mugs/', basePath: '/fr' })).toBe('/shop/mugs/');
-  });
-
-  it('only strips whole segments: a page that starts like a language is a page', () => {
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/fr/french-press', basePath: '/fr' })).toBe('/french-press');
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/french-press' })).toBe('/fr/french-press');
-    // Active is the default (no prefix to strip): `/fr` as a path is a page there.
-    expect(href(EN_DEFAULT, 'en', 'zh-CN', { pathname: '/fr-news' })).toBe('/zh-cn/fr-news');
-  });
-
-  it('strips the active prefix once: a page slug equal to the prefix survives', () => {
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/fr/fr', basePath: '/fr' })).toBe('/fr');
-  });
-
-  it('handles a path-based host (basePath carries the store slug)', () => {
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/acme/shop', basePath: '/acme' })).toBe('/acme/fr/shop');
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/acme/fr/shop', basePath: '/acme/fr' })).toBe('/acme/shop');
-    expect(href(EN_DEFAULT, 'fr', 'zh-CN', { pathname: '/acme/fr', basePath: '/acme/fr' })).toBe('/acme/zh-cn');
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/acme/fr', basePath: '/acme/fr' })).toBe('/acme');
-  });
-
-  it('also copes with a non-localized basePath', () => {
-    expect(href(EN_DEFAULT, 'fr', 'en', { pathname: '/acme/fr/shop', basePath: '/acme' })).toBe('/acme/shop');
-    expect(href(EN_DEFAULT, 'en', 'fr', { pathname: '/acme', basePath: '/acme' })).toBe('/acme/fr');
-  });
-
-  it('matches the active prefix case-insensitively', () => {
-    expect(href(EN_DEFAULT, 'zh-CN', 'en', { pathname: '/ZH-CN/shop' })).toBe('/shop');
-  });
-
-  it('works on an old backend without is_default (primary is the default)', () => {
-    const old = normalizeStoreLocales([
-      { locale: 'en', name: 'English', native_name: 'English', is_primary: true, path_prefix: '' },
-      { locale: 'fr', name: 'French', native_name: 'Français', is_primary: false, path_prefix: 'fr' },
-    ]);
-    expect(old.map((l) => [l.locale, l.is_default, l.path_prefix])).toEqual([
-      ['en', true, ''],
-      ['fr', false, 'fr'],
-    ]);
-    expect(href(old, 'en', 'fr', { pathname: '/shop' })).toBe('/fr/shop');
-    expect(href(old, 'fr', 'en', { pathname: '/fr/shop', basePath: '/fr' })).toBe('/shop');
-  });
-});
-
-describe('normalizeStoreLocales', () => {
-  it('returns [] for nothing usable', () => {
-    expect(normalizeStoreLocales(undefined)).toEqual([]);
-    expect(normalizeStoreLocales(null)).toEqual([]);
-    expect(normalizeStoreLocales([])).toEqual([]);
-    expect(normalizeStoreLocales([{} as never, { locale: '' }, null as never])).toEqual([]);
-    expect(normalizeStoreLocales('fr' as never)).toEqual([]);
-  });
-
-  it('puts the default first and keeps the rest in order', () => {
-    const out = normalizeStoreLocales([
-      row('fr', { path_prefix: 'fr' }),
-      row('en', { is_primary: true, is_default: true }),
-      row('de', { path_prefix: 'de' }),
-    ]);
-    expect(out.map((l) => l.locale)).toEqual(['en', 'fr', 'de']);
-  });
-
-  it('keeps exactly one default, forces its prefix empty and fills empty prefixes', () => {
-    const out = normalizeStoreLocales([
-      row('en', { is_default: true, path_prefix: 'en' }),
-      row('FR', { is_default: true, path_prefix: '' }),
-      row('pt-BR', { path_prefix: '' }),
-    ]);
-    expect(out.map((l) => [l.locale, l.is_default, l.path_prefix])).toEqual([
-      ['en', true, ''],
-      ['FR', false, 'fr'],
-      ['pt-BR', false, 'pt-br'],
-    ]);
-  });
-
-  it('drops repeated codes, tolerates extra fields and defaults missing ones', () => {
-    const out = normalizeStoreLocales([
-      { locale: 'en', is_primary: true, extra: 'ignored' } as StoreLocaleInput,
-      { locale: 'EN', is_primary: false },
-      { locale: 'ar', path_prefix: 'ar', dir: 'rtl' },
-    ]);
-    expect(out).toHaveLength(2);
-    expect(out[0]).toMatchObject({ locale: 'en', name: 'en', native_name: 'en', dir: 'ltr', hreflang: 'en', html_lang: 'en' });
-    expect(out[0]).not.toHaveProperty('extra');
-    expect(out[1]?.dir).toBe('rtl');
-  });
-
-  it('accepts the storefront row shape without mapping', () => {
-    const storefrontRows: Array<{
-      locale: string; name: string; native_name: string; is_primary: boolean; is_default: boolean;
-      path_prefix: string; hreflang: string; html_lang: string; dir: string;
-    }> = [
-      { locale: 'en', name: 'English', native_name: 'English', is_primary: true, is_default: true, path_prefix: '', hreflang: 'en', html_lang: 'en', dir: 'ltr' },
-    ];
-    const accepted: readonly StoreLocaleInput[] = storefrontRows;
-    const exact: StoreLocale = normalizeStoreLocales(accepted)[0]!;
-    // A storefront-typed value is assignable to StoreLocale as well.
-    const back: typeof storefrontRows[number] = exact;
-    expect(back.locale).toBe('en');
-  });
-});
-
-describe('active and default resolution', () => {
-  it('resolves the request locale case-insensitively, unknown/null to the default', () => {
-    expect(resolveActiveLocale(EN_DEFAULT, 'zh-cn').locale).toBe('zh-CN');
-    expect(resolveActiveLocale(EN_DEFAULT, 'fr').locale).toBe('fr');
-    expect(resolveActiveLocale(EN_DEFAULT, null).locale).toBe('en');
-    expect(resolveActiveLocale(EN_DEFAULT, 'xx').locale).toBe('en');
-    expect(resolveActiveLocale(FR_DEFAULT, undefined).locale).toBe('fr');
-  });
-
-  it('falls back to English for an empty list', () => {
-    expect(defaultStoreLocale([]).locale).toBe('en');
-    expect(resolveActiveLocale([], 'fr').path_prefix).toBe('');
-  });
-});

package/tests/locale-transport.test.tsx

@@ -1,321 +0,0 @@
-import { renderToStaticMarkup } from 'react-dom/server';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { JSX, ReactNode } from 'react';
-import {
-  LOCALE_CODE_HEADER,
-  localeCacheKeySegment,
-  parseLocaleCode,
-  withLocalePath,
-  withLocaleQuery,
-  withLocaleTag,
-  withLocaleTags,
-} from '../utils/locale';
-import { StorefrontProvider, useStorefrontLocale } from '../provider';
-import { ShopPrefetchProvider, useShop } from '../hooks/use-shop';
-import { normalizeShopQuery, type ShopPrefetch } from '../utils/shop-query';
-import type { Product } from '../types/product';
-
-/**
- * Theme-kit locale transport: the API answers `?locale=<code>`
- * with translated text, the proxy sets `x-queek-locale` for published
- * non-primary locales only, and every kit transport forwards it additively —
- * no locale anywhere means byte-identical behaviour to before.
- */
-
-const requestHeaders = vi.hoisted(() => ({ headers: new Headers(), throwOutsideScope: false }));
-
-vi.mock('next/headers', () => ({
-  headers: async () => {
-    if (requestHeaders.throwOutsideScope) throw new Error('headers() outside request scope');
-    return requestHeaders.headers;
-  },
-}));
-
-function setRequestHeaders(values: Record<string, string>): void {
-  requestHeaders.headers = new Headers(values);
-  requestHeaders.throwOutsideScope = false;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  setRequestHeaders({});
-});
-
-describe('parseLocaleCode (header / prop / override validation)', () => {
-  it('accepts well-formed codes', () => {
-    for (const code of ['en', 'zh', 'yo', 'pcm', 'zh-CN', 'pt-BR', 'zh-TW', 'sr-Latn']) {
-      expect(parseLocaleCode(code), code).toBe(code);
-    }
-  });
-
-  it('ignores anything else (never an error)', () => {
-    for (const bad of [
-      '',
-      'e',
-      'toolongcode123',
-      'zh!',
-      'en_US',
-      'en us',
-      'shop',
-      'products',
-      '-zh',
-      'zh-',
-      '123',
-      null,
-      undefined,
-      42,
-      {},
-    ]) {
-      expect(parseLocaleCode(bad), JSON.stringify(bad)).toBeNull();
-    }
-  });
-
-  it('enforces the 12-char cap', () => {
-    expect(parseLocaleCode('ab-cdefghij')).toBe('ab-cdefghij');
-    expect(parseLocaleCode('ab-cdefghijk')).toBeNull();
-  });
-});
-
-describe('withLocaleQuery (backend URL building)', () => {
-  it('adds locale=<code> to a query', () => {
-    expect(withLocaleQuery({ per_page: 24, page: 1 }, 'zh-CN')).toEqual({ per_page: 24, page: 1, locale: 'zh-CN' });
-  });
-
-  it('builds a query from nothing when locale is set', () => {
-    expect(withLocaleQuery(undefined, 'zh')).toEqual({ locale: 'zh' });
-  });
-
-  it('returns the input untouched when no valid locale is present', () => {
-    const query = { per_page: 24 };
-    expect(withLocaleQuery(query, null)).toBe(query);
-    expect(withLocaleQuery(query, undefined)).toBe(query);
-    expect(withLocaleQuery(query, '!!')).toBe(query);
-    expect(withLocaleQuery(undefined, null)).toBeUndefined();
-  });
-});
-
-describe('cache tag suffixing (`<tag>:locale:<code>`)', () => {
-  it('suffixes every tag, lower-cased', () => {
-    expect(withLocaleTag('v:acme:theme', 'zh-CN')).toBe('v:acme:theme:locale:zh-cn');
-    expect(withLocaleTags(['v:acme', 'v:acme:theme', 'v:acme:menus'], 'zh')).toEqual([
-      'v:acme:locale:zh',
-      'v:acme:theme:locale:zh',
-      'v:acme:menus:locale:zh',
-    ]);
-  });
-
-  it('returns tags untouched when no valid locale is present', () => {
-    const tags = ['v:acme', 'v:acme:theme'];
-    expect(withLocaleTags(tags, null)).toBe(tags);
-    expect(withLocaleTags(tags, 'shop')).toBe(tags);
-    expect(withLocaleTag('v:acme', null)).toBe('v:acme');
-  });
-});
-
-describe('withLocalePath (SDK-backed callers with path strings only)', () => {
-  it('appends locale, respecting an existing query string', () => {
-    expect(withLocalePath('/client/store/products/egusi', 'zh')).toBe('/client/store/products/egusi?locale=zh');
-    expect(withLocalePath('/x?limit=4', 'zh-CN')).toBe('/x?limit=4&locale=zh-CN');
-  });
-
-  it('returns the path untouched without a valid locale', () => {
-    expect(withLocalePath('/client/store/products/egusi', null)).toBe('/client/store/products/egusi');
-    expect(withLocalePath('/x?limit=4', 'nope!')).toBe('/x?limit=4');
-  });
-});
-
-describe('localeCacheKeySegment (client cache keys)', () => {
-  it('separates locales and never collides with unset', () => {
-    expect(localeCacheKeySegment('zh')).toBe('zh');
-    expect(localeCacheKeySegment('zh-CN')).toBe('zh-cn');
-    expect(localeCacheKeySegment(null)).toBe('');
-    expect(localeCacheKeySegment('!!')).toBe('');
-    expect(localeCacheKeySegment('zh')).not.toBe(localeCacheKeySegment(null));
-  });
-});
-
-describe('server transport (sdk/server-store-client)', () => {
-  type CapturedInit = RequestInit & { next?: { revalidate: number; tags: string[] } };
-
-  async function capturedGet(path: string, query?: Record<string, string | number>, locale?: string): Promise<{ url: string; init: CapturedInit }> {
-    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) => ({ ok: true, json: async () => ({ data: {} }) }));
-    vi.stubGlobal('fetch', fetchMock);
-    const { createServerStoreClient } = await import('../sdk/server-store-client');
-    const client = createServerStoreClient('acme', 'http://origin.test');
-    await client.get(path, query, locale);
-    const [[url, init]] = fetchMock.mock.calls as unknown as Array<[string, CapturedInit]>;
-    return { url, init };
-  }
-
-  it('appends locale=<code> and suffixes every tag when the header is set', async () => {
-    setRequestHeaders({ [LOCALE_CODE_HEADER]: 'zh-CN', host: 'acme.test' });
-    const { url, init } = await capturedGet('/info');
-    expect(url).toContain('locale=zh-CN');
-    expect(init.next?.tags).toEqual(['v:acme:locale:zh-cn', 'v:acme:profile:locale:zh-cn']);
-  });
-
-  it('is byte-identical to today with no header', async () => {
-    setRequestHeaders({ host: 'acme.test' });
-    const { url, init } = await capturedGet('/info');
-    expect(url).toBe('http://127.0.0.1:8000/api/v1/client/store/info');
-    expect(init.next).toEqual({ revalidate: 300, tags: ['v:acme', 'v:acme:profile'] });
-  });
-
-  it('ignores an invalid header value', async () => {
-    setRequestHeaders({ [LOCALE_CODE_HEADER]: 'not a locale!!', host: 'acme.test' });
-    const { url, init } = await capturedGet('/info');
-    expect(url).not.toContain('locale=');
-    expect(init.next?.tags).toEqual(['v:acme', 'v:acme:profile']);
-  });
-
-  it('never throws outside a request scope (treated as no locale)', async () => {
-    requestHeaders.throwOutsideScope = true;
-    const { readRequestLocale } = await import('../sdk/server-store-client');
-    await expect(readRequestLocale()).resolves.toBeNull();
-    requestHeaders.throwOutsideScope = false;
-    const { url } = await capturedGet('/info');
-    expect(url).not.toContain('locale=');
-  });
-
-  it('an explicit override wins over the header', async () => {
-    setRequestHeaders({ [LOCALE_CODE_HEADER]: 'zh', host: 'acme.test' });
-    const { url, init } = await capturedGet('/info', undefined, 'fr');
-    expect(url).toContain('locale=fr');
-    expect(init.next?.tags).toEqual(['v:acme:locale:fr', 'v:acme:profile:locale:fr']);
-  });
-
-  it('still bypasses the cache for preview renders, locale or not', async () => {
-    setRequestHeaders({ 'x-queek-preview': '1', [LOCALE_CODE_HEADER]: 'zh', host: 'acme.test' });
-    const { url, init } = await capturedGet('/info');
-    expect(url).toContain('locale=zh');
-    expect(init.next).toBeUndefined();
-    expect(init.cache).toBe('no-store');
-  });
-});
-
-describe('fetchShopPrefetch (api/shop)', () => {
-  async function runPrefetch(vendorSlug = 'demo-store', locale?: string) {
-    const fetchMock = vi.fn(async (_url: string, _init?: RequestInit) => ({ ok: true, json: async () => ({ data: [], has_more: false }) }));
-    vi.stubGlobal('fetch', fetchMock);
-    const { fetchShopPrefetch } = await import('../api/shop');
-    const prefetch = await fetchShopPrefetch(vendorSlug, normalizeShopQuery({}), locale);
-    const urls = (fetchMock.mock.calls as unknown as Array<[string]>).map(([url]) => String(url));
-    const productsCall = urls.find((url) => url.includes('/products')) ?? '';
-    return { prefetch, productsCall };
-  }
-
-  it('forwards the request locale and echoes it for the seed match', async () => {
-    setRequestHeaders({ [LOCALE_CODE_HEADER]: 'zh', host: 'x.test' });
-    const { prefetch, productsCall } = await runPrefetch();
-    expect(productsCall).toContain('locale=zh');
-    expect(prefetch?.locale).toBe('zh');
-  });
-
-  it('fetches exactly as before with no locale (echo null)', async () => {
-    setRequestHeaders({ host: 'x.test' });
-    const { prefetch, productsCall } = await runPrefetch();
-    expect(productsCall).not.toContain('locale=');
-    expect(prefetch?.locale).toBeNull();
-  });
-});
-
-function product(id: string, title: string): Product {
-  return { id, title, slug: id } as unknown as Product;
-}
-
-function render(children: ReactNode, locale?: string | null): string {
-  return renderToStaticMarkup(
-    <StorefrontProvider
-      vendor={{ id: 'v1', slug: 'demo-store', name: 'Demo Store' } as never}
-      config={{} as never}
-      menus={[]}
-      {...(locale !== undefined ? { locale } : {})}
-    >
-      {children}
-    </StorefrontProvider>,
-  );
-}
-
-function LocaleProbe(): JSX.Element {
-  const locale = useStorefrontLocale();
-  return <span data-locale={locale ?? 'none'} />;
-}
-
-describe('StorefrontProvider locale prop + useStorefrontLocale', () => {
-  it('exposes the validated locale', () => {
-    expect(render(<LocaleProbe />, 'zh-CN')).toContain('data-locale="zh-CN"');
-  });
-
-  it('is null without the prop (unchanged behaviour)', () => {
-    expect(render(<LocaleProbe />)).toContain('data-locale="none"');
-  });
-
-  it('is null for an invalid prop (ignored, never an error)', () => {
-    expect(render(<LocaleProbe />, 'not a locale!!')).toContain('data-locale="none"');
-  });
-});
-
-const SEED_QUERY = normalizeShopQuery({ categorySlug: 'soups', keyword: 'egusi', sort: 'popular', page: 1, perPage: 24 });
-
-function seedPrefetch(locale?: string | null): ShopPrefetch {
-  const prefetch: ShopPrefetch = {
-    query: SEED_QUERY,
-    products: [product('p1', 'Egusi Soup')],
-    pagination: { currentPage: 1, perPage: 24, hasMore: false },
-  };
-  if (locale !== undefined) prefetch.locale = locale;
-  return prefetch;
-}
-
-function Grid(props: Parameters<typeof useShop>[0]): JSX.Element {
-  const { products, isLoading } = useShop(props);
-  return (
-    <ul data-loading={String(isLoading)}>
-      {products.map((p) => <li key={p.id}>{p.title}</li>)}
-    </ul>
-  );
-}
-
-function renderGrid(prefetch: ShopPrefetch | null, locale?: string | null): string {
-  return render(
-    <ShopPrefetchProvider value={prefetch}>
-      <Grid categorySlug="soups" keyword="egusi" sort="popular" page={1} perPage={24} />
-    </ShopPrefetchProvider>,
-    locale,
-  );
-}
-
-describe('useShop locale cache separation (seed match)', () => {
-  it('seeds from a prefetch fetched in the same locale', () => {
-    const html = renderGrid(seedPrefetch('zh'), 'zh');
-    expect(html).toContain('data-loading="false"');
-    expect(html).toContain('Egusi Soup');
-  });
-
-  it('ignores a prefetch fetched in another locale and refetches', () => {
-    const html = renderGrid(seedPrefetch('zh'), null);
-    expect(html).toContain('data-loading="true"');
-    expect(html).not.toContain('Egusi Soup');
-  });
-
-  it('keeps the old no-locale behaviour: absent echo means primary', () => {
-    const html = renderGrid(seedPrefetch(), null);
-    expect(html).toContain('data-loading="false"');
-    expect(html).toContain('Egusi Soup');
-  });
-});
-
-describe('no-locale regression (byte-identical guarantee)', () => {
-  it('server and client helpers pass input through untouched', () => {
-    const query = { per_page: 24, page: 1 };
-    expect(withLocaleQuery(query, null)).toBe(query);
-    const tags = ['v:acme', 'v:acme:products'];
-    expect(withLocaleTags(tags, null)).toBe(tags);
-    expect(withLocalePath('/client/store/products', null)).toBe('/client/store/products');
-    expect(parseLocaleCode(null)).toBeNull();
-  });
-
-  it('every hook still renders without a provider locale', () => {
-    expect(renderGrid(seedPrefetch(), null)).toContain('data-loading="false"');
-  });
-});

package/tests/manifest-parity.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { FRAMEWORK_BLOCK_MANIFEST, FRAMEWORK_OWNED_TYPES } from '../shared-blocks/manifest';
-import type { BlockType } from '../types/block';
-import type { FrameworkBlockType } from '../types/theme';
-
-/**
- * Three places declare "this block type is framework-owned" and must never
- * drift: `types/theme.ts` `FrameworkBlockType`, `shared-blocks/manifest.ts`
- * `FRAMEWORK_OWNED_TYPES`, and `page-renderer.tsx`'s switch (checked here by
- * proxy — every framework-owned type must at least have a manifest entry, or
- * a theme's Section Library drawer would offer a block the renderer has no
- * variant list for).
- */
-describe('framework-owned block manifest parity', () => {
-  // Mirrors `FrameworkBlockType` in types/theme.ts — TypeScript enforces the
-  // literal union is exhaustive against `BlockType` here (compile error if
-  // one is added without the other), so this list doubles as the type check.
-  const frameworkBlockTypes: FrameworkBlockType[] = [
-    'divider',
-    'embed',
-    'video',
-    'table',
-    'button',
-    'image',
-    'reviews',
-    'faq',
-    'callout',
-    'quote',
-    'product_qa',
-    'metaobjects',
-  ];
-
-  it('FrameworkBlockType and FRAMEWORK_OWNED_TYPES name the same set', () => {
-    expect(new Set(frameworkBlockTypes)).toEqual(FRAMEWORK_OWNED_TYPES);
-  });
-
-  it('every framework-owned type (except content, handled specially) has a manifest entry', () => {
-    for (const type of FRAMEWORK_OWNED_TYPES) {
-      expect(FRAMEWORK_BLOCK_MANIFEST[type], `${type} missing from FRAMEWORK_BLOCK_MANIFEST`).toBeDefined();
-      expect(FRAMEWORK_BLOCK_MANIFEST[type].length).toBeGreaterThan(0);
-    }
-  });
-
-  it('metaobjects is a real BlockType', () => {
-    const type: BlockType = 'metaobjects';
-    expect(FRAMEWORK_OWNED_TYPES.has(type)).toBe(true);
-  });
-
-  it('metaobjects manifest declares grid (default) and list variants', () => {
-    const variants = FRAMEWORK_BLOCK_MANIFEST.metaobjects;
-    expect(variants.map((v) => v.id)).toEqual(expect.arrayContaining(['grid', 'list']));
-    expect(variants.find((v) => v.default)?.id).toBe('grid');
-  });
-});

package/tests/markdown-render.test.ts

@@ -1,46 +0,0 @@
-import React from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import { describe, expect, it } from 'vitest';
-import { renderMarkdown } from '../utils/markdown';
-
-/**
- * A heading immediately followed by other content, with no blank line between them, must
- * not be swallowed whole into the heading — `utils/markdown.tsx` once treated an entire
- * blank-line-delimited block as heading text the moment it matched a heading prefix.
- * Merchant copy often writes "### Our Offerings\n- item\n- item" with no blank line, which
- * is common, valid markdown — the list must not disappear into the h3.
- */
-
-function html(markdown: string): string {
-  return renderToStaticMarkup(React.createElement(React.Fragment, null, ...renderMarkdown(markdown)));
-}
-
-describe('renderMarkdown heading + trailing-content handling', () => {
-  it('a heading immediately followed by a list (no blank line) renders both, not one heading swallowing the list', () => {
-    const out = html(
-      '### Our Offerings\n- Latest fashion apparel for men, women, and children\n- Accessories to complement every outfit',
-    );
-
-    expect(out).toContain('<h3');
-    expect(out).toContain('Our Offerings');
-    expect(out).toContain('<ul');
-    expect(out).toContain('<li>Latest fashion apparel for men, women, and children</li>');
-    expect(out).toContain('<li>Accessories to complement every outfit</li>');
-    expect(out).not.toMatch(/<h3[^>]*>[^<]*Latest fashion/);
-  });
-
-  it('a heading immediately followed by a paragraph (no blank line) renders both, not one heading swallowing the text', () => {
-    const out = html('## Our Story\nWe hand-pick every piece.');
-
-    expect(out).toBe('<h2>Our Story</h2><p>We hand-pick every piece.</p>');
-  });
-
-  it('a heading with nothing after it still renders alone (regression guard)', () => {
-    expect(html('## Our Story')).toBe('<h2>Our Story</h2>');
-  });
-
-  it('a heading followed by a blank-line-separated paragraph still renders as two blocks (regression guard)', () => {
-    const out = html('## Our Story\n\nWe hand-pick every piece.');
-    expect(out).toBe('<h2>Our Story</h2><p>We hand-pick every piece.</p>');
-  });
-});