@fayz-ai/storefront 0.9.0 → 0.10.0

package/src/router.ts

@@ -1,49 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import { hashRouterAdapter } from '@fayz-ai/core'
-
-// Minimal hash router for the storefront. Deliberately not react-router:
-// an SDK package shipping a router dependency creates singleton hazards
-// under source-alias dev setups, and six routes don't justify one.
-
-const adapter = hashRouterAdapter()
-
-export function navigateTo(to: string): void {
-  adapter.navigate(to)
-}
-
-export function useHashPath(): string {
-  const [path, setPath] = useState(() => adapter.getCurrentPath() || '/')
-  useEffect(() => {
-    const unsub = adapter.onPathChange((p) => {
-      setPath(p || '/')
-      window.scrollTo(0, 0)
-    })
-    return unsub
-  }, [])
-  return path
-}
-
-/** Match '/product/:slug' against '/product/leather-backpack' → { slug: 'leather-backpack' } */
-export function matchPath(pattern: string, path: string): Record<string, string> | null {
-  const cleanPath = (path.split('?')[0] ?? '').replace(/\/+$/, '') || '/'
-  const patternParts = pattern.split('/').filter(Boolean)
-  const pathParts = cleanPath.split('/').filter(Boolean)
-  if (patternParts.length !== pathParts.length) return null
-  const params: Record<string, string> = {}
-  for (let i = 0; i < patternParts.length; i++) {
-    const pat = patternParts[i]!
-    const part = pathParts[i]!
-    if (pat.startsWith(':')) params[pat.slice(1)] = decodeURIComponent(part)
-    else if (pat !== part) return null
-  }
-  return params
-}
-
-export interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
-  to: string
-}
-
-/** Real anchor (#/path) — middle-click/cmd-click friendly, Playwright friendly. */
-export function Link({ to, children, ...rest }: LinkProps) {
-  return React.createElement('a', { href: `#${to}`, ...rest }, children)
-}

package/src/scaffold.tsx

@@ -1,115 +0,0 @@
-import React from 'react'
-import { registerScaffold, defineApp } from '@fayz-ai/core'
-import type { AppManifest, BackendProvider } from '@fayz-ai/core'
-import { StorefrontConfigProvider, resolveConfig } from './config'
-import type { StorefrontConfig } from './config'
-import type { StorefrontTheme } from './theme'
-import type { HomeConfig, NavLink, FooterConfig } from './sections'
-import { initStorefrontRuntime, StorefrontShell } from './createStorefrontApp'
-import './blocks' // ensure section blocks are registered
-
-type StorefrontBackendProvider = NonNullable<StorefrontConfig['backend']>['provider']
-const runtimeConfigRegistry = new Map<string, StorefrontConfig>()
-
-// ---------------------------------------------------------------------------
-// Storefront scaffold — renders a store from a pure-data AppManifest. The
-// storefront surface keeps its declarative config under surface.options, so the
-// mapping is loss-free for the serializable fields (the code escape hatches —
-// custom provider/adapter/logo — arrive via the registries instead).
-// ---------------------------------------------------------------------------
-
-function slug(name: string): string {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'app'
-}
-
-/** StorefrontConfig → AppManifest (the sugar-to-data direction). */
-export function defineStorefront(config: StorefrontConfig): AppManifest {
-  const id = slug(config.name)
-  runtimeConfigRegistry.set(id, config)
-  const backendProvider = (config.backend?.provider ?? (config.provider ? 'custom' : 'mock')) as BackendProvider
-
-  return defineApp({
-    id,
-    name: config.name,
-    backend: {
-      provider: backendProvider,
-      url: config.backend?.url,
-    },
-    locale: {
-      default: config.locale ?? 'pt-BR',
-      supported: [config.locale ?? 'pt-BR'],
-      currency: config.currency ?? 'BRL',
-    },
-    theme: config.theme as Record<string, unknown> | undefined,
-    surfaces: {
-      storefront: {
-        scaffold: 'storefront',
-        options: {
-          announcement: config.announcement,
-          home: config.home,
-          nav: config.nav,
-          footer: config.footer,
-          shipping: config.shipping,
-          features: config.features,
-          catalog: config.catalog,
-        },
-      },
-    },
-  })
-}
-
-/** AppManifest → StorefrontConfig (the data-to-render direction). */
-function manifestToStorefrontConfig(manifest: AppManifest, surfaceName: string): StorefrontConfig {
-  const runtimeConfig = runtimeConfigRegistry.get(manifest.id)
-  const surface = manifest.surfaces[surfaceName]
-  const o = (surface?.options ?? {}) as Record<string, unknown>
-  return {
-    ...runtimeConfig,
-    name: manifest.name,
-    currency: (manifest.locale as { currency?: string } | undefined)?.currency,
-    locale: (manifest.locale as { default?: string } | undefined)?.default,
-    theme: manifest.theme as StorefrontTheme | undefined,
-    announcement: o.announcement as string | undefined,
-    home: o.home as HomeConfig | undefined,
-    nav: o.nav as NavLink[] | undefined,
-    footer: o.footer as FooterConfig | undefined,
-    shipping: o.shipping as StorefrontConfig['shipping'],
-    features: o.features as StorefrontConfig['features'],
-    catalog: o.catalog as StorefrontConfig['catalog'],
-    backend: {
-      provider: manifest.backend?.provider as StorefrontBackendProvider,
-      url: manifest.backend?.url,
-    },
-    components: runtimeConfig?.components,
-    routes: runtimeConfig?.routes,
-    provider: runtimeConfig?.provider,
-    auth: runtimeConfig?.auth,
-    logo: runtimeConfig?.logo,
-  }
-}
-
-export function StorefrontScaffold({ manifest, surface }: { manifest: AppManifest; surface: string }) {
-  const config = React.useMemo(() => manifestToStorefrontConfig(manifest, surface), [manifest, surface])
-  const resolved = React.useMemo(() => resolveConfig(config), [config])
-  const inited = React.useRef(false)
-  if (!inited.current) {
-    initStorefrontRuntime(config)
-    inited.current = true
-  }
-  return (
-    <StorefrontConfigProvider value={resolved}>
-      <StorefrontShell />
-    </StorefrontConfigProvider>
-  )
-}
-StorefrontScaffold.displayName = 'StorefrontScaffold'
-
-// Registration is lazy (called from the storefront renderApp wrapper and
-// createStorefront*) so that importing the @fayz-ai/storefront barrel stays
-// side-effect-free and tree-shakable.
-let storefrontScaffoldRegistered = false
-export function registerStorefrontScaffold(): void {
-  if (storefrontScaffoldRegistered) return
-  storefrontScaffoldRegistered = true
-  registerScaffold('storefront', StorefrontScaffold, { source: 'sdk', label: 'Storefront' })
-}

package/src/sections.ts

@@ -1,116 +0,0 @@
-import type { HeroVariant } from './theme'
-import type React from 'react'
-
-// ---------------------------------------------------------------------------
-// Home-page section blueprint — the storefront's PageConfig equivalent.
-// A template (or the Fayz agent) declares the home as an ordered list of
-// typed sections; HomePage renders them. Every recurring block found in the
-// Nuvemshop research maps to one section type.
-// ---------------------------------------------------------------------------
-
-export interface HeroSlide {
-  title: string
-  subtitle?: string
-  cta?: string
-  href?: string
-  /** Image URL; omit for a gradient placeholder derived from `hue` */
-  image?: string
-  hue?: number
-  /** Editorial boxed copy block (Uyuni) instead of free overlay */
-  boxed?: boolean
-}
-
-export interface MediaCarouselItem {
-  title: string
-  subtitle?: string
-  eyebrow?: string
-  cta?: string
-  href?: string
-  image: string
-  imageAlt?: string
-  align?: 'start' | 'center' | 'end'
-}
-
-export type StorefrontSection =
-  | { type: 'hero'; variant: HeroVariant; slides: HeroSlide[]; height?: 'tall' | 'medium' }
-  | {
-      type: 'mediaCarousel'
-      items: MediaCarouselItem[]
-      height?: 'medium' | 'tall' | 'screen'
-      autoplayMs?: number
-      overlay?: 'dark' | 'soft' | 'none'
-      className?: string
-    }
-  | { type: 'categories'; style: 'bubbles' | 'tiles'; title?: string }
-  | {
-      type: 'products'
-      title: string
-      subtitle?: string
-      /** Small-caps label above the title (e.g. 'curadoria') */
-      eyebrow?: string
-      /** 'sale' = compareAtPrice set; 'new' = newest first; 'all' = catalog order */
-      filter?: 'sale' | 'new' | 'all'
-      limit?: number
-    }
-  | {
-      type: 'productSlider'
-      title: string
-      subtitle?: string
-      eyebrow?: string
-      filter?: 'sale' | 'new' | 'all'
-      categoryName?: string
-      collection?: string
-      limit?: number
-      cta?: string
-      href?: string
-      className?: string
-    }
-  | { type: 'benefits'; items: Array<{ icon: string; title: string; text?: string }> }
-  | { type: 'banner'; title: string; subtitle?: string; eyebrow?: string; cta?: string; href?: string; image?: string; hue?: number }
-  | { type: 'manifesto'; title?: string; text: string }
-  | { type: 'testimonials'; title?: string; items: Array<{ quote: string; author: string }> }
-  | { type: 'newsletter'; title?: string; subtitle?: string }
-
-/** @deprecated Use StorefrontSection. Kept for existing generated stores. */
-export type HomeSection = StorefrontSection
-
-export interface HomeConfig {
-  sections: readonly StorefrontSection[]
-}
-
-export interface NavLink {
-  label: string
-  to: string
-}
-
-export interface FooterConfig {
-  about?: string
-  contact?: { phone?: string; email?: string; address?: string }
-  social?: Array<{ label: string; href: string }>
-  credit?: React.ReactNode
-  labels?: {
-    categories?: string
-    navigation?: string
-    contact?: string
-    viewAll?: string
-    purchases?: string
-    privacy?: string
-    terms?: string
-    returns?: string
-  }
-}
-
-/** Wide gradient SVG data-URI — deterministic hero/banner art, no network. */
-export function bannerPlaceholder(label: string, hueA: number, hueB: number, w = 1600, h = 700): string {
-  const svg =
-    `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}">` +
-    `<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1">` +
-    `<stop offset="0" stop-color="hsl(${hueA},40%,78%)"/>` +
-    `<stop offset="1" stop-color="hsl(${hueB},45%,55%)"/>` +
-    `</linearGradient></defs>` +
-    `<rect width="${w}" height="${h}" fill="url(#g)"/>` +
-    `<circle cx="${w * 0.8}" cy="${h * 0.3}" r="${h * 0.45}" fill="hsla(${hueB},50%,90%,0.25)"/>` +
-    `<circle cx="${w * 0.15}" cy="${h * 0.85}" r="${h * 0.35}" fill="hsla(${hueA},45%,30%,0.12)"/>` +
-    `</svg>`
-  return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`
-}

package/src/shop.ts

@@ -1,4 +0,0 @@
-// Front-door re-export of the Fayz API shop provider (@fayz-ai/sdk/shop) so
-// storefront apps import `createFayzShopProvider` from
-// `@fayz-ai/storefront/shop` instead of depending on @fayz-ai/sdk directly.
-export * from '@fayz-ai/sdk/shop'

package/src/stores/cart.store.ts

@@ -1,185 +0,0 @@
-import { create } from 'zustand'
-import { persist } from 'zustand/middleware'
-import type { Product } from '@fayz-ai/shop/types'
-import { roundCents } from '../format'
-import type { ResolvedStorefrontConfig } from '../config'
-import { useDeliveryStore, selectQuotedShipping } from './delivery.store'
-import {
-  formatProductOptionSelection,
-  normalizeProductOptionSelection,
-  productOptionSelectionKey,
-  type ProductOptionSelection,
-} from '../product-options'
-
-export interface CartLine {
-  lineId: string
-  productId: string
-  slug: string
-  name: string
-  sku: string | null
-  options: ProductOptionSelection
-  optionsLabel: string
-  unitPrice: number
-  quantity: number
-  imageUrl: string | null
-  /** inventoryCount at add time — clamps quantity */
-  maxQuantity: number
-}
-
-export interface CartState {
-  lines: CartLine[]
-  discountCode: string | null
-  discountPercent: number
-  isOpen: boolean
-  /** Line most recently added — lets the drawer briefly highlight it. */
-  justAddedLineId: string | null
-  addItem(product: Product, qty?: number, options?: ProductOptionSelection): void
-  setQuantity(lineId: string, qty: number): void
-  removeItem(lineId: string): void
-  applyDiscount(code: string, percent: number): void
-  clearDiscount(): void
-  clear(): void
-  openDrawer(): void
-  closeDrawer(): void
-  /** Drop persisted lines the active backend can no longer resolve (e.g. a cart
-   *  built in an earlier mock-mode session, whose ids don't exist live). The
-   *  resolver returns false only for a definitive "not found"; on error it must
-   *  return true so a transient failure never discards a legit line. */
-  reconcile(resolve: (line: CartLine) => Promise<boolean>): Promise<void>
-}
-
-export const useCartStore = create<CartState>()(
-  persist(
-    (set, get) => ({
-      lines: [],
-      discountCode: null,
-      discountPercent: 0,
-      isOpen: false,
-      justAddedLineId: null,
-
-      addItem: (product, qty = 1, options) =>
-        set((state) => {
-          const normalizedOptions = normalizeProductOptionSelection(options)
-          const optionKey = productOptionSelectionKey(normalizedOptions)
-          const lineId = optionKey ? `${product.id}:${optionKey}` : product.id
-          const existing = state.lines.find((l) => (l.lineId ?? l.productId) === lineId)
-          if (existing) {
-            const nextQty = Math.min(existing.quantity + qty, existing.maxQuantity || Infinity)
-            return {
-              // Auto-open the cart on add — the standard premium "slide-in cart"
-              // signal — and flag the line so the drawer can highlight it.
-              isOpen: true,
-              justAddedLineId: lineId,
-              lines: state.lines.map((l) =>
-                (l.lineId ?? l.productId) === lineId ? { ...l, lineId, quantity: nextQty } : l,
-              ),
-            }
-          }
-          const image = product.images.find((i) => i.isPrimary) ?? product.images[0]
-          const line: CartLine = {
-            lineId,
-            productId: product.id,
-            slug: product.slug,
-            name: product.name,
-            sku: product.sku,
-            options: normalizedOptions,
-            optionsLabel: formatProductOptionSelection(normalizedOptions),
-            unitPrice: product.price,
-            quantity: Math.min(qty, product.inventoryCount || Infinity),
-            imageUrl: image?.url ?? null,
-            maxQuantity: product.inventoryCount,
-          }
-          return { isOpen: true, justAddedLineId: lineId, lines: [...state.lines, line] }
-        }),
-
-      setQuantity: (lineId, qty) =>
-        set((state) => {
-          if (qty <= 0) return { lines: state.lines.filter((l) => (l.lineId ?? l.productId) !== lineId) }
-          return {
-            lines: state.lines.map((l) =>
-              (l.lineId ?? l.productId) === lineId
-                ? { ...l, quantity: Math.min(qty, l.maxQuantity || Infinity) }
-                : l,
-            ),
-          }
-        }),
-
-      removeItem: (lineId) =>
-        set((state) => ({ lines: state.lines.filter((l) => (l.lineId ?? l.productId) !== lineId) })),
-
-      applyDiscount: (code, percent) => set({ discountCode: code, discountPercent: percent }),
-      clearDiscount: () => set({ discountCode: null, discountPercent: 0 }),
-      clear: () => set({ lines: [], discountCode: null, discountPercent: 0 }),
-      openDrawer: () => set({ isOpen: true }),
-      closeDrawer: () => set({ isOpen: false, justAddedLineId: null }),
-
-      reconcile: async (resolve) => {
-        const lines = get().lines
-        if (lines.length === 0) return
-        const keep = await Promise.all(
-          lines.map((line) => resolve(line).catch(() => true)),
-        )
-        const kept = lines.filter((_, i) => keep[i])
-        if (kept.length !== lines.length) set({ lines: kept })
-      },
-    }),
-    {
-      name: 'fayz.storefront.cart.v1',
-      partialize: (state) => ({
-        lines: state.lines,
-        discountCode: state.discountCode,
-        discountPercent: state.discountPercent,
-      }),
-    },
-  ),
-)
-
-// ---------------------------------------------------------------------------
-// Money selectors — the single place cart math happens. Checkout passes these
-// exact values to createOrder so drawer totals always match order totals.
-// ---------------------------------------------------------------------------
-
-export const selectCount = (s: Pick<CartState, 'lines'>): number =>
-  s.lines.reduce((n, l) => n + l.quantity, 0)
-
-export const selectSubtotal = (s: Pick<CartState, 'lines'>): number =>
-  roundCents(s.lines.reduce((sum, l) => sum + l.unitPrice * l.quantity, 0))
-
-export const selectDiscountTotal = (s: Pick<CartState, 'lines' | 'discountPercent'>): number =>
-  roundCents(selectSubtotal(s) * (s.discountPercent / 100))
-
-/**
- * Freight to display.
- *
- * When the shopper has given a CEP and the store quoted it, that quote wins —
- * it came from the same shipping_zones rows shop_place_order will charge from.
- * Otherwise this falls back to the store-wide rate in config, which is what
- * every storefront did before zones existed.
- *
- * The subtotal is PRE-discount on both sides of this. That is 0017's rule, and
- * the quote is requested against the same number, so a coupon can never make
- * the cart and the order disagree.
- *
- * Read through getState() rather than a hook because this is a plain selector
- * called from several screens; components that render the value subscribe to
- * useDeliveryStore themselves so a fresh quote re-renders them.
- */
-export const selectShipping = (
-  s: Pick<CartState, 'lines'>,
-  cfg: ResolvedStorefrontConfig,
-): number => {
-  if (s.lines.length === 0) return 0
-  const subtotal = selectSubtotal(s)
-
-  const quoted = selectQuotedShipping(useDeliveryStore.getState(), subtotal)
-  if (quoted != null) return quoted
-
-  if (cfg.shipping.freeAbove != null && subtotal >= cfg.shipping.freeAbove) return 0
-  return cfg.shipping.flatRate
-}
-
-export const selectTotal = (
-  s: Pick<CartState, 'lines' | 'discountPercent'>,
-  cfg: ResolvedStorefrontConfig,
-): number =>
-  roundCents(selectSubtotal(s) - selectDiscountTotal(s) + selectShipping(s, cfg))

package/src/stores/catalog.store.ts

@@ -1,39 +0,0 @@
-import { create } from 'zustand'
-
-export type CatalogSort = 'newest' | 'price-asc' | 'price-desc' | 'name'
-
-export interface CatalogState {
-  search: string
-  categoryId: string | null
-  priceMin: number | null
-  priceMax: number | null
-  inStockOnly: boolean
-  sort: CatalogSort
-  setSearch(search: string): void
-  setCategoryId(categoryId: string | null): void
-  setPriceMin(priceMin: number | null): void
-  setPriceMax(priceMax: number | null): void
-  setInStockOnly(inStockOnly: boolean): void
-  setSort(sort: CatalogSort): void
-  reset(): void
-}
-
-const initial = {
-  search: '',
-  categoryId: null,
-  priceMin: null,
-  priceMax: null,
-  inStockOnly: false,
-  sort: 'newest' as CatalogSort,
-}
-
-export const useCatalogStore = create<CatalogState>()((set) => ({
-  ...initial,
-  setSearch: (search) => set({ search }),
-  setCategoryId: (categoryId) => set({ categoryId }),
-  setPriceMin: (priceMin) => set({ priceMin }),
-  setPriceMax: (priceMax) => set({ priceMax }),
-  setInStockOnly: (inStockOnly) => set({ inStockOnly }),
-  setSort: (sort) => set({ sort }),
-  reset: () => set(initial),
-}))

package/src/stores/delivery.store.ts

@@ -1,152 +0,0 @@
-import { create } from 'zustand'
-import { persist } from 'zustand/middleware'
-import { lookupPostalCode, normalizePostalCode, type PostalAddress } from '@fayz-ai/core'
-import { getShopProvider } from '@fayz-ai/shop/runtime'
-import type { ShippingQuoteOption } from '@fayz-ai/shop/types'
-
-/**
- * Where the shopper wants it delivered, decided before the cart exists.
- *
- * Two different things live here and they are persisted differently on purpose:
- *
- *   the ADDRESS is durable — a CEP maps to the same street for years, and
- *   carrying it to checkout is the whole point (the buyer types the number and
- *   nothing else);
- *
- *   the QUOTE is not persisted at all. It is a price, and a price restored from
- *   localStorage is a price the shopper can edit with devtools. It is re-asked
- *   on demand, and resolved for the current cart through resolveOptionRate —
- *   the same rule shop_shipping_for applies — so it can never go stale. The
- *   order is charged from shop_place_order, which recomputes from the same
- *   zones and ignores anything the client sends.
- */
-
-export type DeliveryStatus = 'idle' | 'loading' | 'served' | 'unserved' | 'error'
-
-export interface DeliveryState {
-  postalCode: string
-  address: PostalAddress | null
-  options: ShippingQuoteOption[]
-  selectedZoneId: string | null
-  status: DeliveryStatus
-  error: string | null
-
-  /** Look the CEP up and quote it. `subtotal` decides free-above thresholds. */
-  resolve: (postalCode: string, subtotal: number) => Promise<void>
-  selectZone: (zoneId: string) => void
-  clear: () => void
-}
-
-const EMPTY = {
-  postalCode: '',
-  address: null,
-  options: [] as ShippingQuoteOption[],
-  selectedZoneId: null,
-  status: 'idle' as DeliveryStatus,
-  error: null,
-}
-
-export const useDeliveryStore = create<DeliveryState>()(
-  persist(
-    (set, get) => ({
-      ...EMPTY,
-
-      async resolve(postalCode: string, subtotal: number) {
-        const code = normalizePostalCode(postalCode)
-        if (code.length !== 8) {
-          set({ ...EMPTY, postalCode, status: 'error', error: 'Digite os 8 dígitos do CEP.' })
-          return
-        }
-
-        set({ postalCode: code, status: 'loading', error: null })
-
-        // The QUOTE comes first and is the answer that matters. Whether we
-        // deliver to a postcode, and for how much, is decided entirely by our
-        // own zones against eight digits — it does not need to know the street.
-        //
-        // Doing it the other way round made the delivery answer depend on a
-        // third party: with ViaCEP slow or rate-limited, a perfectly serviceable
-        // address reported an error instead of a price.
-        let options: ShippingQuoteOption[] = []
-        try {
-          options = (await getShopProvider().quoteShipping?.(code, subtotal)) ?? []
-        } catch {
-          set({ ...EMPTY, postalCode: code, status: 'error',
-                error: 'Não foi possível calcular o frete agora. Tente de novo.' })
-          return
-        }
-
-        // The ADDRESS is the convenience layer: it saves the buyer typing, and
-        // losing it costs typing, not the sale. Failures here never change the
-        // delivery verdict already decided above.
-        let address: PostalAddress | null = null
-        let notFound = false
-        try {
-          address = await lookupPostalCode(code)
-          notFound = address === null
-        } catch {
-          address = null
-        }
-
-        set({
-          postalCode: code,
-          address,
-          options,
-          selectedZoneId: options[0]?.zoneId ?? null,
-          // A store with no zones configured quotes nothing, and that must NOT
-          // read as "we don't deliver here" — it falls back to the store-wide
-          // flat rate, which the cart already knows how to show.
-          status: options.length > 0 ? 'served' : 'unserved',
-          // Reported alongside the price, not instead of it: the CEP may be
-          // mistyped even though its range is covered.
-          error: notFound ? 'CEP não encontrado. Confira os números.' : null,
-        })
-      },
-
-      selectZone(zoneId: string) {
-        if (get().options.some((option) => option.zoneId === zoneId)) set({ selectedZoneId: zoneId })
-      },
-
-      clear() {
-        set({ ...EMPTY })
-      },
-    }),
-    {
-      name: 'fayz.storefront.delivery.v1',
-      // Deliberately NOT persisting `options`: a rehydrated
-      // price would be shown as current without anything having quoted it. The
-      // address survives, the money is asked for again.
-      partialize: (state) => ({ postalCode: state.postalCode, address: state.address }),
-      onRehydrateStorage: () => (state) => {
-        if (state?.address) state.status = 'idle'
-      },
-    },
-  ),
-)
-
-/**
- * The freight for the chosen zone at THIS subtotal, or null when there is no
- * zone in play (no CEP yet, or a store that configured none) and the caller
- * should use the store-wide rate. Null never means free.
- *
- * The free-above rule is applied here rather than trusting the `rate` the
- * server resolved, because that one was resolved for whatever the cart held at
- * quote time. Re-deriving from `baseRate`/`freeAbove` — the same CASE
- * shop_shipping_for runs — means adding an item can never leave a stale price
- * on screen. An earlier version fell back to the config flat rate when the
- * quote went stale, which showed R$ 8 (the flat rate) for an address in an
- * R$ 18 zone: shown one number, charged another.
- */
-export function resolveOptionRate(option: ShippingQuoteOption, subtotal: number): number {
-  if (option.freeAbove != null && subtotal >= option.freeAbove) return 0
-  return option.baseRate
-}
-
-export const selectQuotedShipping = (
-  state: Pick<DeliveryState, 'options' | 'selectedZoneId' | 'status'>,
-  subtotal: number,
-): number | null => {
-  if (state.status !== 'served') return null
-  const option = state.options.find((o) => o.zoneId === state.selectedZoneId) ?? state.options[0]
-  return option ? resolveOptionRate(option, subtotal) : null
-}