@usequeek/theme-kit 0.1.23 → 0.1.24

package/tests/powered-by-queek.test.tsx

@@ -1,65 +0,0 @@
-import React from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import { describe, expect, it } from 'vitest';
-import { PoweredByQueek } from '../components/powered-by-queek';
-import { StorefrontContext } from '../provider';
-
-const BASE = 'https://usequeek.com/business?utm_source=powered_by&utm_medium=storefront';
-
-function render(props?: { className?: string; hidden?: boolean }, vendor?: { id: string; slug: string | null }): string {
-  const element = React.createElement(PoweredByQueek, props);
-
-  if (!vendor) return renderToStaticMarkup(element);
-
-  return renderToStaticMarkup(
-    React.createElement(StorefrontContext.Provider, { value: { vendor } as never }, element),
-  );
-}
-
-describe('PoweredByQueek', () => {
-  it('links to the Queek business page with the attribution contract intact', () => {
-    const html = render();
-
-    expect(html).toContain('<a');
-    expect(html).toContain(`href="${BASE}"`);
-    expect(html).toContain('target="_blank"');
-    expect(html).toContain('rel="noopener noreferrer"');
-  });
-
-  it('tags the link with the store slug as utm_campaign', () => {
-    const html = render(undefined, { id: 'uuid-1', slug: 'demo-store' });
-
-    expect(html).toContain(`href="${BASE}&amp;utm_campaign=demo-store"`);
-    expect(html).toContain('rel="noopener noreferrer"');
-  });
-
-  it('omits utm_campaign (never the internal UUID) when the store has no slug', () => {
-    const html = render(undefined, { id: 'uuid-1', slug: null });
-
-    expect(html).not.toContain('utm_campaign');
-    expect(html).not.toContain('uuid-1');
-  });
-
-  it('omits utm_campaign (never errors) when no storefront provider is mounted', () => {
-    expect(render()).not.toContain('utm_campaign');
-  });
-
-  it('renders "Powered by Queek" with the brand hook for theme styling', () => {
-    const html = render();
-
-    expect(html).toContain('core-powered-by');
-    expect(html).toContain('Powered by');
-    expect(html).toContain('<strong class="core-powered-by__brand">Queek</strong>');
-  });
-
-  it('passes a footer positioning class through alongside the core class', () => {
-    const html = render({ className: 'qn-footer4__powered' });
-
-    expect(html).toContain('class="core-powered-by qn-footer4__powered"');
-  });
-
-  it('renders nothing when hidden', () => {
-    expect(render({ hidden: true })).toBe('');
-    expect(render({ hidden: true }, { id: 'uuid-1', slug: 'demo-store' })).toBe('');
-  });
-});

package/tests/powered-by-url.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { POWERED_BY_QUEEK_URL, poweredByQueekUrl } from '../utils/powered-by';
-
-function params(url: string): Record<string, string> {
-  return Object.fromEntries(new URL(url).searchParams.entries());
-}
-
-describe('poweredByQueekUrl', () => {
-  it('keeps the business-page destination and adds source, medium and campaign', () => {
-    const url = poweredByQueekUrl('demo-store');
-
-    expect(url.startsWith(`${POWERED_BY_QUEEK_URL}?`)).toBe(true);
-    expect(params(url)).toEqual({
-      utm_source: 'powered_by',
-      utm_medium: 'storefront',
-      utm_campaign: 'demo-store',
-    });
-  });
-
-  it.each([undefined, null, '', '   '])('omits utm_campaign for a blank campaign (%j)', (campaign) => {
-    expect(params(poweredByQueekUrl(campaign))).toEqual({
-      utm_source: 'powered_by',
-      utm_medium: 'storefront',
-    });
-  });
-
-  it('preserves an existing query and overrides only its own utm keys', () => {
-    const url = poweredByQueekUrl('shop-1', 'https://usequeek.com/business?plan=pro&utm_source=old&utm_campaign=stale');
-
-    expect(params(url)).toEqual({
-      plan: 'pro',
-      utm_source: 'powered_by',
-      utm_medium: 'storefront',
-      utm_campaign: 'shop-1',
-    });
-  });
-
-  it('drops a stale utm_campaign when the new campaign is blank', () => {
-    expect(params(poweredByQueekUrl(null, 'https://usequeek.com/business?utm_campaign=stale'))).not.toHaveProperty('utm_campaign');
-  });
-
-  it('url-encodes the campaign and is deterministic (SSR-safe, no window/Date)', () => {
-    const url = poweredByQueekUrl('a b&c');
-
-    expect(url).toContain('utm_campaign=a+b%26c');
-    expect(params(url).utm_campaign).toBe('a b&c');
-    expect(poweredByQueekUrl('a b&c')).toBe(url);
-  });
-});

package/tests/product-images.test.ts

@@ -1,242 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { LegacyProductLike, Product } from '../types/product';
-import { normalizeProduct } from '../utils/product-normalizer';
-import { buildMediaFrames, getHoverImage, getSlideshowImages } from '../utils/product-media';
-
-function raw(overrides: LegacyProductLike = {}): LegacyProductLike {
-  return { id: 'p1', title: 'Ankara Gown', slug: 'ankara-gown', ...overrides };
-}
-
-function viewVariants(url: string) {
-  return {
-    thumb: null,
-    card: { url: '/card.jpg', w: 480, h: 480 },
-    card2x: { url: '/card2x.jpg', w: 800, h: 800 },
-    view: { url, w: 1600, h: 1600 },
-    original: { url: '/orig.jpg', w: 2400, h: 2400 },
-  };
-}
-
-describe('normalizeProduct images', () => {
-  it('carries backend images verbatim, ordered primary-first', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          thumbnail: 'https://cdn/x/thumb.jpg',
-          images: [
-            { id: 11, url: 'https://cdn/x/primary.jpg', alt: 'Front', variants: null },
-            { id: 12, url: 'https://cdn/x/side.jpg', alt: 'Side', variants: viewVariants('https://cdn/x/side-view.jpg') },
-          ],
-        },
-      }),
-    );
-
-    expect(product.media.images).toHaveLength(2);
-    expect(product.media.images?.[0]).toMatchObject({ id: 11, url: 'https://cdn/x/primary.jpg' });
-    expect(product.media.images?.[1]?.variants).toMatchObject({ view: { url: 'https://cdn/x/side-view.jpg' } });
-    // The featured shortcut is untouched.
-    expect(product.media.image).toBe('https://cdn/x/primary.jpg');
-  });
-
-  it('drops blank entries from a provided images list', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          images: [
-            { id: 11, url: '', alt: 'Blank' },
-            { id: 12, url: 'https://cdn/x/side.jpg', alt: 'Side' },
-          ],
-        },
-      }),
-    );
-
-    expect(product.media.images?.map((i) => i.url)).toEqual(['https://cdn/x/side.jpg']);
-  });
-
-  it('ignores a legacy gallery key: images come from images only', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          images: [{ id: 11, url: 'https://cdn/x/primary.jpg', alt: 'Front' }],
-          gallery: [
-            { id: 12, url: 'https://cdn/x/side.jpg', alt: 'Side' },
-            { id: 13, url: 'https://cdn/x/back.jpg', alt: 'Back' },
-          ],
-        } as LegacyProductLike['media'],
-      }),
-    );
-
-    expect(product.media.images?.map((i) => i.url)).toEqual(['https://cdn/x/primary.jpg']);
-    expect(product.media).not.toHaveProperty('gallery');
-  });
-
-  it('rejects a misspelled images key at compile time instead of silently yielding []', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          // @ts-expect-error `imagess` is not a media key — the narrowed type turns this typo into a compile error, not a [].
-          imagess: [{ id: 1, url: 'https://cdn/x/a.jpg' }],
-        },
-      }),
-    );
-
-    expect(product.media.images).toEqual([]);
-  });
-
-  it('derives nothing from image/gallery on old payloads: no images list means []', () => {
-    const product = normalizeProduct(
-      raw({
-        image: 'https://cdn/x/primary.jpg',
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          gallery: [
-            { id: 11, url: 'https://cdn/x/primary.jpg', alt: 'Dupe of primary' },
-            { id: 12, url: 'https://cdn/x/side.jpg', alt: 'Side' },
-            { id: 13, url: '', alt: 'Blank' },
-          ],
-        } as LegacyProductLike['media'],
-      }),
-    );
-
-    expect(product.media.images).toEqual([]);
-    expect(product.media).not.toHaveProperty('gallery');
-    // The primary shortcut itself is untouched.
-    expect(product.media.image).toBe('https://cdn/x/primary.jpg');
-  });
-
-  it('yields [] for a payload with no imagery at all and no gallery key', () => {
-    const none = normalizeProduct(raw({}));
-
-    expect(none.media.images).toEqual([]);
-    expect(none.media).not.toHaveProperty('gallery');
-  });
-
-  it('yields [] when a provided images list is entirely blank, even with gallery present', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          gallery: [{ id: 12, url: 'https://cdn/x/side.jpg' }],
-          images: [{ id: 11, url: '' }],
-        } as LegacyProductLike['media'],
-      }),
-    );
-
-    expect(product.media.images).toEqual([]);
-    expect(product.media).not.toHaveProperty('gallery');
-  });
-});
-
-describe('getHoverImage / getSlideshowImages', () => {
-  const product = (urls: string[]): Product =>
-    normalizeProduct(
-      raw({
-        media: {
-          image: urls[0] ?? null,
-          images: urls.map((url, i) => ({ id: i + 1, url })),
-        },
-      }),
-    );
-
-  it('returns images[1] and null unless two images exist', () => {
-    expect(getHoverImage(product([]))).toBeNull();
-    expect(getHoverImage(product(['https://cdn/x/a.jpg']))).toBeNull();
-    expect(getHoverImage(product(['https://cdn/x/a.jpg', 'https://cdn/x/b.jpg']))).toBe(
-      'https://cdn/x/b.jpg',
-    );
-  });
-
-  it('returns the ordered slideshow list', () => {
-    const list = getSlideshowImages(product(['https://cdn/x/a.jpg', 'https://cdn/x/b.jpg']));
-    expect(list.map((i) => i.url)).toEqual(['https://cdn/x/a.jpg', 'https://cdn/x/b.jpg']);
-  });
-
-  it('treats a missing images key as no slideshow', () => {
-    const legacy = normalizeProduct(raw({ image: 'https://cdn/x/a.jpg' }));
-    delete legacy.media.images;
-    expect(getSlideshowImages(legacy)).toEqual([]);
-    expect(getHoverImage(legacy)).toBeNull();
-  });
-});
-
-describe('buildMediaFrames reads images', () => {
-  it('renders identical frames with and without a legacy gallery key present', () => {
-    const images = [
-      { id: 11, url: 'https://cdn/x/primary.jpg', alt: 'Ankara Gown' },
-      { id: 12, url: 'https://cdn/x/side.jpg', alt: 'Side' },
-      { id: 13, url: 'https://cdn/x/back.jpg', alt: 'Back' },
-    ];
-    const withGallery = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          original: 'https://cdn/x/primary-orig.jpg',
-          gallery: [{ id: 99, url: 'https://cdn/x/stale.jpg', alt: 'Stale' }],
-          images,
-        } as LegacyProductLike['media'],
-      }),
-    );
-
-    const stripped = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          original: 'https://cdn/x/primary-orig.jpg',
-          images,
-        },
-      }),
-    );
-
-    const withUrls = buildMediaFrames(withGallery).map((f) => f.url);
-    const strippedUrls = buildMediaFrames(stripped).map((f) => f.url);
-    expect(withUrls).toEqual(strippedUrls);
-    expect(withUrls).toEqual([
-      'https://cdn/x/primary-orig.jpg',
-      'https://cdn/x/side.jpg',
-      'https://cdn/x/back.jpg',
-    ]);
-    expect(withUrls).not.toContain('https://cdn/x/stale.jpg');
-  });
-
-  it('builds no frames from a gallery-only payload: gallery urls never render', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          gallery: [
-            { id: 12, url: 'https://cdn/x/side.jpg', alt: 'Side' },
-            { id: 13, url: 'https://cdn/x/back.jpg', alt: 'Back' },
-          ],
-        } as LegacyProductLike['media'],
-      }),
-    );
-
-    // Only the media.image primary single-frame fallback survives — the
-    // gallery urls are ignored, not derived into images.
-    expect(product.media.images).toEqual([]);
-    expect(buildMediaFrames(product).map((f) => f.url)).toEqual(['https://cdn/x/primary.jpg']);
-  });
-
-  it('prefers the view tier off images entries and appends video last', () => {
-    const product = normalizeProduct(
-      raw({
-        media: {
-          image: 'https://cdn/x/primary.jpg',
-          images: [
-            { id: 11, url: 'https://cdn/x/primary.jpg', variants: viewVariants('https://cdn/x/primary-view.jpg') },
-            { id: 12, url: 'https://cdn/x/side.jpg' },
-          ],
-          video_url: 'https://cdn/x/clip.mp4',
-        },
-      }),
-    );
-
-    const frames = buildMediaFrames(product);
-    expect(frames.map((f) => f.type)).toEqual(['image', 'image', 'video']);
-    expect(frames[0].url).toBe('https://cdn/x/primary-view.jpg');
-    expect(frames[2].url).toBe('https://cdn/x/clip.mp4');
-  });
-});

package/tests/product-metafields.test.tsx

@@ -1,154 +0,0 @@
-import React from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import { describe, expect, it } from 'vitest';
-import { ProductMetafields } from '../components/product-metafields';
-import type { MetafieldValue, Product } from '../types/product';
-
-function makeProduct(metafields?: Record<string, MetafieldValue>): Product {
-  return {
-    shop_id: 'shop-1',
-    id: 'product-1',
-    p_id: 1,
-    title: 'Test product',
-    slug: 'test-product',
-    excerpt: null,
-    description: null,
-    kind: 'physical',
-    status: 'active',
-    barcode: null,
-    currency: 'NGN',
-    pricing: {
-      base_amount: 1000,
-      sale_amount: 800,
-      compare_at_amount: 1000,
-      discount_amount: 200,
-      discount_percent: 20,
-      is_price_from: false,
-      tax_inclusive: false,
-      price_range: { min_amount: 800, max_amount: 800 },
-    },
-    shop: { id: 'shop-1', name: 'Shop', slug: 'shop', logo: null, rating: 0, rating_count: 0 },
-    media: { thumbnail: null, image: null },
-    inventory: { in_stock: true, tracking: false, quantity: 5 },
-    variants_count: 0,
-    review_summary: { rating: 0, review_count: 0 },
-    flags: { featured: false, is_marketplace: false, is_wholesale: false, is_new: false },
-    categories: [],
-    options: [],
-    variants: [],
-    addons: [],
-    reviews: [],
-    metafields,
-    created_at: null,
-    updated_at: null,
-  };
-}
-
-function render(metafields?: Record<string, MetafieldValue>, definitions?: Record<string, { name: string; type: string }>): string {
-  return renderToStaticMarkup(React.createElement(ProductMetafields, { product: makeProduct(metafields), definitions }));
-}
-
-describe('ProductMetafields', () => {
-  it('renders nothing when the product has no metafields', () => {
-    expect(render(undefined)).toBe('');
-    expect(render({})).toBe('');
-  });
-
-  it('renders nothing when every value is empty', () => {
-    expect(render({ fabric: '', tags: [] })).toBe('');
-  });
-
-  it('renders text with the definition label', () => {
-    const html = render(
-      { fabric: 'Ankara cotton' },
-      { fabric: { name: 'Fabric', type: 'single_line_text' } },
-    );
-
-    expect(html).toContain('core-metafields');
-    expect(html).toContain('Fabric');
-    expect(html).toContain('Ankara cotton');
-    expect(html).toContain('<p');
-  });
-
-  it('falls back to a humanised key label for unknown handles', () => {
-    const html = render({ care_instructions: 'Hand wash only' });
-
-    expect(html).toContain('Care instructions');
-    expect(html).toContain('Hand wash only');
-  });
-
-  it('renders multi_line and rich text preformatted', () => {
-    expect(render({ notes: 'line one\nline two' }, { notes: { name: 'Notes', type: 'multi_line_text' } })).toContain('<pre');
-    expect(render({ story: '<p>rich</p>' }, { story: { name: 'Story', type: 'rich_text' } })).toContain('<pre');
-  });
-
-  it('renders scalar lists as bullets', () => {
-    const html = render({ tags: ['cotton', 'handmade'] }, { tags: { name: 'Tags', type: 'list.single_line_text' } });
-
-    expect(html).toContain('<ul');
-    expect(html).toContain('<li');
-    expect(html).toContain('cotton');
-    expect(html).toContain('handmade');
-  });
-
-  it('renders booleans as Yes/No', () => {
-    expect(render({ gift: true }, { gift: { name: 'Gift wrap', type: 'boolean' } })).toContain('>Yes<');
-    expect(render({ gift: false }, { gift: { name: 'Gift wrap', type: 'boolean' } })).toContain('>No<');
-  });
-
-  it('renders dates localised instead of raw ISO', () => {
-    const html = render({ drop: '2026-09-20' }, { drop: { name: 'Drop date', type: 'date' } });
-
-    expect(html).not.toContain('2026-09-20');
-    expect(html).toContain('2026');
-  });
-
-  it('renders urls as links', () => {
-    const html = render({ lookbook: 'https://example.com/look' }, { lookbook: { name: 'Lookbook', type: 'url' } });
-
-    expect(html).toContain('<a');
-    expect(html).toContain('href="https://example.com/look"');
-  });
-
-  it('renders media_id as an image', () => {
-    const html = render({ swatch: 'https://cdn.example.com/swatch.jpg' }, { swatch: { name: 'Swatch', type: 'media_id' } });
-
-    expect(html).toContain('<img');
-    expect(html).toContain('src="https://cdn.example.com/swatch.jpg"');
-  });
-
-  it('renders a linked entry as a card with its fields', () => {
-    const html = render(
-      {
-        designer: {
-          p_id: 1000,
-          type: 'designer',
-          handle: 'adaeze',
-          display_name: 'Adaeze',
-          fields: { name: 'Adaeze', instagram: '@adaeze' },
-        },
-      },
-      { designer: { name: 'Designer', type: 'metaobject_reference' } },
-    );
-
-    expect(html).toContain('core-metafields__entry-card');
-    expect(html).toContain('Adaeze');
-    expect(html).toContain('@adaeze');
-  });
-
-  it('renders a list of entries as a grid of cards', () => {
-    const html = render(
-      {
-        ingredients: [
-          { p_id: 1, type: 'ingredient', handle: 'shea', display_name: 'Shea', fields: { name: 'Shea' } },
-          { p_id: 2, type: 'ingredient', handle: 'cocoa', display_name: 'Cocoa', fields: { name: 'Cocoa' } },
-        ],
-      },
-      { ingredients: { name: 'Ingredients', type: 'list.metaobject_reference' } },
-    );
-
-    expect(html).toContain('core-metafields__entry-grid');
-    expect(html).toContain('Shea');
-    expect(html).toContain('Cocoa');
-  });
-});

package/tests/public-surface.test.ts

@@ -1,35 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { describe, expect, it } from 'vitest';
-
-const ROOT = resolve(__dirname, '..');
-
-/**
- * The barrels re-export by RELATIVE path — the kit carries no `@/` alias, so it
- * resolves when imported from outside this repo. `./types/theme` and
- * `@usequeek/theme-kit/types/theme` name the same module; normalise to the second.
- */
-function barrelModules(file: string): Set<string> {
-  const source = readFileSync(join(ROOT, file), 'utf8');
-  return new Set(
-    [...source.matchAll(/from '\.\/([^']+)'/g)].map((m) => m[1]),
-  );
-}
-
-/**
- * `index.ts` + `client.ts` declare the surface a theme may build against — the
- * set that ships as `@usequeek/theme-kit`.
- *
- * Every module the barrels declare must exist.
- */
-describe('core public surface (kit-internal)', () => {
-  const declared = new Set([...barrelModules('index.ts'), ...barrelModules('client.ts')]);
-
-  it('declares nothing that no longer exists', () => {
-    const missing = [...declared].filter(
-      (mod) => !['.ts', '.tsx', '/index.ts', '/index.tsx'].some((ext) => existsSync(join(ROOT, mod + ext))),
-    );
-
-    expect(missing).toEqual([]);
-  });
-});

package/tests/shop-query.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  SHOP_DEFAULT_PER_PAGE,
-  normalizeShopQuery,
-  parseShopResponse,
-  parseShopSearchParams,
-  sameShopQuery,
-  shopRequestParams,
-} from '../utils/shop-query';
-
-/**
- * The server's /shop prefetch only saves the browser a fetch when both sides
- * build the same query — these are the rules both share.
- */
-describe('shop query (shared by useShop and the server prefetch)', () => {
-  it('applies the same defaults useShop always has', () => {
-    expect(normalizeShopQuery()).toEqual({ categorySlug: null, keyword: null, sort: 'latest', page: 1, perPage: SHOP_DEFAULT_PER_PAGE });
-    expect(SHOP_DEFAULT_PER_PAGE).toBe(24);
-  });
-
-  it('treats a blank or padded keyword like the request does', () => {
-    expect(normalizeShopQuery({ keyword: '   ' }).keyword).toBeNull();
-    expect(normalizeShopQuery({ keyword: '  rice ' }).keyword).toBe('rice');
-    expect(sameShopQuery(normalizeShopQuery({ keyword: '' }), normalizeShopQuery({ keyword: null }))).toBe(true);
-  });
-
-  it('distinguishes every field that changes the page fetched', () => {
-    const base = normalizeShopQuery({ categorySlug: 'soups', keyword: 'egusi', sort: 'popular', page: 2, perPage: 24 });
-    for (const change of [{ categorySlug: 'rice' }, { keyword: 'okra' }, { sort: 'price_low' as const }, { page: 3 }, { perPage: 8 }]) {
-      expect(sameShopQuery(base, normalizeShopQuery({ ...base, ...change }))).toBe(false);
-    }
-    expect(sameShopQuery(base, normalizeShopQuery({ ...base }))).toBe(true);
-  });
-
-  it('reads the /shop URL exactly as useShopParams always has', () => {
-    const read = (qs: string) => parseShopSearchParams((key) => new URLSearchParams(qs).get(key));
-    expect(read('')).toEqual({ categorySlug: null, keyword: '', sort: 'latest', page: 1 });
-    expect(read('category=soups&q=egusi&sort=price_high&page=3')).toEqual({ categorySlug: 'soups', keyword: 'egusi', sort: 'price_high', page: 3 });
-    expect(read('sort=cheapest&page=0').sort).toBe('latest');
-    expect(read('page=abc').page).toBe(1);
-    expect(read('page=2.7').page).toBe(2);
-  });
-
-  it('sends the params the storefront products endpoint expects', () => {
-    expect(shopRequestParams(normalizeShopQuery())).toEqual({ per_page: 24, page: 1, sort: 'latest' });
-    expect(shopRequestParams(normalizeShopQuery({ categorySlug: 'soups', keyword: ' egusi ', sort: 'popular', page: 2 })))
-      .toEqual({ per_page: 24, page: 2, category_slug: 'soups', keyword: 'egusi', sort: 'popular' });
-  });
-
-  it('reads the walk state top-level: the page it asked for, has_more from the API, no totals', () => {
-    const query = normalizeShopQuery({ page: 2 });
-    const page = parseShopResponse({ data: [], has_more: true, next_cursor: 'eyJ2IjoxfQ', meta: { listing_mode: 'listing' } } as never, query);
-    expect(page.pagination).toEqual({ currentPage: 2, perPage: 24, hasMore: true });
-
-    const last = parseShopResponse({ data: [], has_more: false, next_cursor: null } as never, normalizeShopQuery());
-    expect(last.pagination).toEqual({ currentPage: 1, perPage: 24, hasMore: false });
-
-    // A legacy paginator echo (the old meta.pagination/meta.current_page) is
-    // never read: the page is the one asked for, has_more defaults to false.
-    const legacy = parseShopResponse({ data: [], meta: { pagination: { current_page: 9, last_page: 12, total: 280, has_more: true } } } as never, query);
-    expect(legacy.pagination).toEqual({ currentPage: 2, perPage: 24, hasMore: false });
-    expect(Object.keys(legacy.pagination).sort()).toEqual(['currentPage', 'hasMore', 'perPage']);
-  });
-});