@thorprovider/blocks 2.0.0 → 3.0.0

package/src/lib/contracts-server-boundary.test.ts

@@ -1,52 +0,0 @@
-// Task 6.7: `use client` must apply only to the UI entrypoint, never to the
-// pure-Zod contracts entrypoint, so server code can import and compose schemas.
-// The tsup config previously applied a global `banner`, which leaked the
-// directive onto the contracts bundle; the fix moves it into the UI source.
-//
-// The server-importable *behavior* of the contracts entry is exercised in the
-// runtime catalog boundary test (`@thorprovider/runtime`), which imports
-// `@thorprovider/blocks/contracts` and calls `extend`/`parse` in a Node server
-// context. This test pins the directive placement and the build config.
-import { existsSync, readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-function findPkgRoot(start: string): string {
-  let dir = start
-  while (dir !== dirname(dir)) {
-    const pkg = join(dir, 'package.json')
-    if (existsSync(pkg)) {
-      const parsed = JSON.parse(readFileSync(pkg, 'utf8'))
-      if (parsed.name === '@thorprovider/blocks') return dir
-    }
-    dir = dirname(dir)
-  }
-  throw new Error('@thorprovider/blocks package root not found')
-}
-
-const pkgRoot = findPkgRoot(process.cwd())
-const read = (...parts: string[]) => readFileSync(join(pkgRoot, ...parts), 'utf8')
-const USE_CLIENT = /^['"]use client['"]/
-
-describe('blocks entrypoint boundaries (6.7)', () => {
-  it('marks only the UI entrypoint as a client module', () => {
-    expect(USE_CLIENT.test(read('src', 'index.ts').trimStart())).toBe(true)
-    expect(USE_CLIENT.test(read('src', 'lib', 'contracts.ts').trimStart())).toBe(false)
-  })
-
-  it('has no global tsup banner that would leak use client onto contracts', () => {
-    expect(read('tsup.config.ts')).not.toMatch(/banner\s*:/)
-  })
-
-  it('builds a contracts bundle with no use client directive and a UI bundle with it', () => {
-    const distContracts = join(pkgRoot, 'dist', 'contracts.mjs')
-    const distIndex = join(pkgRoot, 'dist', 'index.mjs')
-    // dist/ is build output; validate it whenever a build has run.
-    if (existsSync(distContracts)) {
-      expect(USE_CLIENT.test(readFileSync(distContracts, 'utf8').trimStart())).toBe(false)
-    }
-    if (existsSync(distIndex)) {
-      expect(USE_CLIENT.test(readFileSync(distIndex, 'utf8').trimStart())).toBe(true)
-    }
-  })
-})

package/src/lib/contracts.test.ts

@@ -1,228 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { z } from 'zod'
-import {
-  categoryCardPropsSchema,
-  categoryGridPropsSchema,
-  navbarPropsSchema,
-  productCardPropsSchema,
-  productGridPropsSchema,
-  storeCategorySchema,
-} from './contracts'
-
-describe('storeCategorySchema', () => {
-  it('accepts flat categories (additive backward compatibility)', () => {
-    const result = storeCategorySchema.safeParse({ label: 'Herramientas', href: '/categorias/herramientas' })
-    expect(result.success).toBe(true)
-  })
-
-  it('accepts a three-level category tree', () => {
-    const result = storeCategorySchema.safeParse({
-      label: 'Mobile Devices',
-      href: '/categorias/mobile-devices-l1',
-      children: [
-        {
-          label: 'Smartphones',
-          href: '/categorias/smartphones',
-          children: [
-            { label: 'Flagship Phones', href: '/categorias/flagship-phones' },
-            { label: 'Mid-Range Phones', href: '/categorias/mid-range-phones' },
-          ],
-        },
-      ],
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('rejects categories missing label or href', () => {
-    expect(storeCategorySchema.safeParse({ label: 'Solo', href: '/categorias/x', children: [{}] }).success).toBe(false)
-    expect(storeCategorySchema.safeParse({}).success).toBe(false)
-  })
-})
-
-describe('productCardPropsSchema', () => {
-  const canonicalItem = {
-    id: 'sku-1',
-    title: 'Llave de impacto',
-    price: { amount: '129.50', currencyCode: 'EUR' },
-  }
-
-  it('accepts a single canonical Money item with the bounded presentation options', () => {
-    expect(productCardPropsSchema.safeParse({ item: canonicalItem }).success).toBe(true)
-    expect(
-      productCardPropsSchema.safeParse({
-        item: canonicalItem,
-        presentation: 'classic',
-        wishlisted: true,
-      }).success,
-    ).toBe(true)
-    expect(
-      productCardPropsSchema.safeParse({ item: canonicalItem, presentation: 'rich' }).success,
-    ).toBe(true)
-  })
-
-  it('rejects a collection in place of the single item', () => {
-    expect(productCardPropsSchema.safeParse({ items: [canonicalItem] }).success).toBe(false)
-  })
-
-  it('rejects legacy numeric-price items', () => {
-    expect(
-      productCardPropsSchema.safeParse({ item: { id: 'p1', title: 'Taladro', price: 49.99, image: '/x.svg' } })
-        .success,
-    ).toBe(false)
-  })
-
-  it('rejects unknown presentation options', () => {
-    expect(
-      productCardPropsSchema.safeParse({ item: canonicalItem, presentation: 'compact' }).success,
-    ).toBe(false)
-  })
-})
-
-describe('productGridPropsSchema', () => {
-  const canonicalItem = {
-    id: 'sku-1',
-    title: 'Llave de impacto',
-    price: { amount: '129.50', currencyCode: 'EUR' },
-  }
-
-  it('accepts a collection with the listing state options', () => {
-    expect(productGridPropsSchema.safeParse({ items: [canonicalItem] }).success).toBe(true)
-    expect(
-      productGridPropsSchema.safeParse({
-        items: [canonicalItem],
-        presentation: 'minimal',
-        heading: 'Destacados',
-        maxItems: 6,
-        wishlistedIds: ['sku-1'],
-        loading: false,
-        skeletonCount: 6,
-        emptyLabel: 'Sin productos',
-      }).success,
-    ).toBe(true)
-  })
-
-  it('declares only serializable keys — no callbacks or label strings', () => {
-    const runtimeOnlyKeys = [
-      'onAddToCart',
-      'onProductClick',
-      'onToggleWishlist',
-      'onViewSimilar',
-      'addToCartLabel',
-      'unavailablePriceLabel',
-      'addToWishlistLabel',
-      'removeFromWishlistLabel',
-      'viewSimilarLabel',
-    ]
-    const schemaOwnedLabelKeys = new Set(['emptyLabel'])
-    const schemas: Array<{ name: string; schema: z.AnyZodObject }> = [
-      { name: 'productCardPropsSchema', schema: productCardPropsSchema },
-      { name: 'productGridPropsSchema', schema: productGridPropsSchema },
-    ]
-
-    for (const { name, schema } of schemas) {
-      const declaredKeys = Object.keys(schema.shape)
-      expect(declaredKeys.length, name).toBeGreaterThan(0)
-      for (const key of declaredKeys) {
-        expect(runtimeOnlyKeys, `${name}.${key}`).not.toContain(key)
-        expect(key, `${name}.${key}`).not.toMatch(/^on[A-Z]/)
-        if (!schemaOwnedLabelKeys.has(key)) {
-          expect(key, `${name}.${key}`).not.toMatch(/Label$/)
-        }
-        expect(schema.shape[key], `${name}.${key}`).not.toBeInstanceOf(z.ZodFunction)
-      }
-    }
-  })
-
-  it('rejects non-positive maxItems and skeletonCount', () => {
-    expect(productGridPropsSchema.safeParse({ items: [], maxItems: 0 }).success).toBe(false)
-    expect(productGridPropsSchema.safeParse({ items: [], skeletonCount: 0 }).success).toBe(false)
-  })
-})
-
-describe('category cell and listing contracts', () => {
-  const category = { id: 'cat-tools', name: 'Herramientas' }
-
-  it('keeps category cell and listing props JSON-serializable and callback-free', () => {
-    const samples: Array<{ name: string; schema: z.AnyZodObject; props: unknown }> = [
-      {
-        name: 'categoryCardPropsSchema',
-        schema: categoryCardPropsSchema,
-        props: { category, presentation: 'grid', browseLabel: 'Explorar' },
-      },
-      {
-        name: 'categoryGridPropsSchema',
-        schema: categoryGridPropsSchema,
-        props: { categories: [category], presentation: 'grid', title: 'Categorías', maxItems: 4 },
-      },
-    ]
-
-    for (const { name, schema, props } of samples) {
-      const parsed = schema.parse(props)
-      expect(JSON.parse(JSON.stringify(parsed)), name).toEqual(parsed)
-      for (const key of Object.keys(schema.shape)) {
-        expect(key, `${name}.${key}`).not.toMatch(/^on[A-Z]/)
-        expect(schema.shape[key], `${name}.${key}`).not.toBeInstanceOf(z.ZodFunction)
-      }
-    }
-  })
-
-  it('keeps display labels serializable strings and rejects a collection in the cell contract', () => {
-    expect(categoryCardPropsSchema.safeParse({ category, browseLabel: () => 'Explorar' }).success).toBe(false)
-    expect(categoryGridPropsSchema.safeParse({ categories: [], emptyLabel: () => 'Vacío' }).success).toBe(false)
-    expect(categoryCardPropsSchema.safeParse({ categories: [category] }).success).toBe(false)
-  })
-})
-
-describe('navbarPropsSchema', () => {
-  const full = {
-    presentation: 'mega' as const,
-    logoText: 'ElectroCuba',
-    logoHref: '/',
-    currentPath: '/tienda',
-    links: [
-      {
-        label: 'Catálogo',
-        groups: [
-          {
-            title: 'Esenciales',
-            items: [{ label: 'Camisas', href: '/camisas', description: 'Cortes diarios', icon: 'shirt' }],
-          },
-        ],
-      },
-      { label: 'Nosotros', href: '/nosotros', emphasis: true },
-    ],
-    featured: {
-      eyebrow: 'Nueva temporada',
-      title: 'Lino',
-      description: 'Capas transpirables',
-      href: '/lino',
-      linkLabel: 'Descubrir',
-      image: '/lino.jpg',
-      imageAlt: 'Camisa de lino',
-    },
-    signIn: { label: 'Entrar', href: '/cuenta' },
-    cta: { label: 'Comprar' },
-    className: 'bg-brand-nav text-brand-nav-foreground',
-  }
-
-  it('round-trips a fully populated header', () => {
-    expect(navbarPropsSchema.parse(full)).toEqual(full)
-  })
-
-  it('requires the brand text and the links list', () => {
-    expect(navbarPropsSchema.safeParse({ ...full, logoText: undefined }).success).toBe(false)
-    expect(navbarPropsSchema.safeParse({ logoText: 'ElectroCuba' }).success).toBe(false)
-  })
-
-  it('rejects non-string hrefs and unknown presentations', () => {
-    expect(navbarPropsSchema.safeParse({ logoText: 'X', links: [{ label: 'Y', href: 42 }] }).success).toBe(false)
-    expect(navbarPropsSchema.safeParse({ ...full, presentation: 'sidebar' }).success).toBe(false)
-  })
-
-  it('cannot carry host bindings across the serializable boundary', () => {
-    const parsed = navbarPropsSchema.parse({ ...full, iconMap: { shirt: () => null }, onSignIn: () => {} })
-
-    expect(parsed).not.toHaveProperty('iconMap')
-    expect(parsed).not.toHaveProperty('onSignIn')
-  })
-})