@thorprovider/storefront 0.3.1 → 0.4.0-mvp.2

package/assets/templates/views/home/schema.ts

@@ -0,0 +1,93 @@
+// Thor Commerce view schema fragment: home
+// Zod mirrors of the block contracts for this view — the single source for the
+// catalog entries and the client-side registry parsing (json-render does not
+// validate props against the catalog itself, so the registry parses here).
+// Kept free of React and server imports so the Server Component module and the
+// 'use client' registry can share one contract.
+
+import { z } from 'zod'
+
+export const ctaSchema = z.object({
+  label: z.string(),
+  href: z.string().optional(),
+})
+
+// Mirrors the StorefrontHero block contract (FeaturedProduct): the block
+// requires every field — including `colors` — to be defined at render.
+export const featuredProductSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  brand: z.string(),
+  price: z.number(),
+  originalPrice: z.number(),
+  rating: z.number(),
+  reviewCount: z.number(),
+  inStock: z.boolean(),
+  isNew: z.boolean(),
+  isOnSale: z.boolean(),
+  image: z.string(),
+  colors: z.array(z.string()),
+})
+
+// Mirrors the Feature1 block contract; `icon` is a NAME here and only becomes
+// a component when the registry resolves it through the shared icon map.
+export const featureItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  icon: z.string(),
+})
+
+// Mirrors the ProductCategory2 block contract (ProductCategory2Category).
+// `itemCount` is optional: when the backend count is unknown the projection
+// omits it (the block renders no count) rather than fabricating a `0`. A real
+// `0` is preserved.
+export const categoryCardSchema = z.object({
+  id: z.string(),
+  handle: z.string().optional(),
+  name: z.string(),
+  description: z.string(),
+  itemCount: z.number().optional(),
+  image: z.string(),
+  trending: z.boolean(),
+})
+
+// Optional editorial hero image (mirrors the StorefrontHero block contract).
+// Rendered as a native `<img>` only when `src` is a non-empty string; omitted
+// entirely when absent, so a blank `src` is never emitted.
+export const heroImageSchema = z.object({
+  src: z.string(),
+  alt: z.string(),
+})
+
+export const storefrontHeroPropsSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  titleAccent: z.string().optional(),
+  badge: z.string().optional(),
+  products: z.array(featuredProductSchema),
+  primaryCta: ctaSchema.optional(),
+  secondaryCta: ctaSchema.optional(),
+  heroImage: heroImageSchema.optional(),
+})
+
+export const featurePropsSchema = z.object({
+  items: z.array(featureItemSchema),
+  badge: z.string().optional(),
+  title: z.string().optional(),
+  description: z.string().optional(),
+})
+
+export const categoryCardsPropsSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  categories: z.array(categoryCardSchema),
+  cta: ctaSchema.optional(),
+})
+
+export type FeaturedProduct = z.infer<typeof featuredProductSchema>
+export type FeatureItem = z.infer<typeof featureItemSchema>
+export type CategoryCard = z.infer<typeof categoryCardSchema>
+export type StorefrontHeroProps = z.infer<typeof storefrontHeroPropsSchema>
+export type FeatureProps = z.infer<typeof featurePropsSchema>
+export type CategoryCardsProps = z.infer<typeof categoryCardsPropsSchema>

package/assets/templates/views/product/content.ts

@@ -0,0 +1,25 @@
+// Thor Commerce view content: product
+// User-owned view content — the labels rendered by the product overview. No
+// reviews are seeded: reviews are rendered only when the backend supplies real
+// ones, so this file must never carry fabricated review data. Reconcile seeds
+// this file once and never rewrites it; the derived view module (./index.tsx)
+// imports it and wires it into the element tree, so your edits here survive
+// `storefront sync` and unit removal. Plain data only: no React and no server
+// imports.
+
+export const productLabels = {
+  sizesLabel: 'Variantes',
+  variantLabel: 'Variante',
+  reviewsLabel: 'Reseñas',
+  addToCartLabel: 'Agregar al carrito',
+  outOfStockLabel: 'Agotado',
+  unavailablePriceLabel: 'Precio no disponible',
+  selectVariantLabel: 'Selecciona una variante',
+  quantityLabel: 'Cantidad',
+}
+
+// Copy for the reviews region. It renders only when the backend supplies real
+// reviews (`/hasProductReviews`); the list itself is never seeded here.
+export const reviewsCopy = {
+  pageTitle: 'Opiniones de clientes',
+}

package/assets/templates/views/product/data.ts

@@ -0,0 +1,50 @@
+// Thor Commerce view data: product
+// User-owned loader shaping for the product view. Reconcile seeds this file once
+// and never rewrites it; the derived view module (./index.tsx) imports these
+// helpers and calls them from its loader, so edits here survive `storefront sync`
+// and unit removal. Pure functions only: no React and no server imports.
+
+import type { CatalogProductDetail } from '@thorprovider/runtime/commerce'
+import type { ProductDetailProduct } from '@thorprovider/blocks'
+
+/**
+ * Map the runtime's canonical product detail (real variants, options,
+ * availability, Money) to the ProductOverview1 block contract.
+ *
+ * Price availability is preserved, not collapsed: a variant whose backend price
+ * is unresolved carries `price: null` (the block treats that as unavailable and
+ * disables purchase), while a backend-resolved valid zero stays `"0"`.
+ */
+export function buildSelectedProduct(
+  detail: CatalogProductDetail | null | undefined,
+): ProductDetailProduct | null {
+  if (!detail) return null
+  return {
+    id: detail.id,
+    handle: detail.handle,
+    title: detail.title,
+    description: detail.description,
+    options: detail.options,
+    variants: detail.variants.map((variant) => ({
+      id: variant.id,
+      title: variant.title,
+      sku: variant.sku,
+      availableForSale: variant.availableForSale,
+      selectedOptions: variant.options,
+      price: variant.price.status === 'available' ? variant.price.money : null,
+      image: variant.image,
+    })),
+    images: detail.images,
+    featuredImage: detail.featuredImage,
+  }
+}
+
+/**
+ * No first-variant shortcut on the product detail surface: nothing is selected
+ * until the shopper explicitly chooses a variant, so the detail's `onAddToCart`
+ * can never silently add the first one. Listing cards use the separate
+ * first-purchasable-variant shortcut instead.
+ */
+export function initialSelectedVariantId(): string | null {
+  return null
+}

package/assets/templates/views/product/index.tsx

@@ -0,0 +1,148 @@
+// Thor Commerce view module: product
+// Server Component module: elements + catalog entries + route + loader only.
+// The client-side component mappings live in ./registry.tsx ('use client'); this
+// module imports them as data so the RSC graph never evaluates @json-render/react
+// on the server. Registered by importing it in ../index.ts. Recipe: recipes.json -> "product".
+
+import { notFound } from 'next/navigation'
+import { loadProductDetail } from '../../commerce'
+import { getDataSource } from '../../store-context'
+import { mountedFeatureNames } from '../../composition'
+import { pageRoot } from '../../spec/page-root'
+import type { StorefrontElement } from '../../spec/types'
+import type { ViewModule } from '../types'
+import { registry } from './registry'
+import { productBreadcrumbProps, productOverviewProps, productReviewsProps } from './props'
+import { buildSelectedProduct, initialSelectedVariantId } from './data'
+import { breadcrumbPropsSchema, productOverviewPropsSchema, reviewsPropsSchema } from './schema'
+
+// The element tree is derived wiring; the rendered props come from the
+// user-owned ./props.ts module so they survive sync and unit removal.
+const elements: Record<string, StorefrontElement> = {
+  // The navigability feature contributes the entity-derived breadcrumb trail.
+  // The element is always wired; the loader returns an empty trail when the
+  // feature is not installed or the backend supplies no category, so the block
+  // renders nothing and removal leaves no dangling navigation aid.
+  'product.breadcrumb': {
+    type: 'Breadcrumb',
+    props: {
+      ...productBreadcrumbProps,
+      items: { $state: '/breadcrumbItems' },
+    },
+  },
+  'product.overview': {
+    type: 'ProductOverview',
+    visible: { $state: '/selectedProduct' },
+    props: productOverviewProps,
+    on: { addToCart: { action: 'addToCart' } },
+  },
+  // Rendered only when the backend supplies real reviews; the list is never
+  // seeded, so an unsupplied review is not shown and no placeholder is invented.
+  'product.reviews': {
+    type: 'Reviews',
+    visible: { $state: '/hasProductReviews' },
+    props: productReviewsProps,
+    on: {
+      submitReview: { action: 'submitReview' },
+      toggleReviewLike: { action: 'toggleReviewLike' },
+    },
+  },
+}
+
+const catalog = {
+  Breadcrumb: {
+    props: breadcrumbPropsSchema,
+    description: 'Migas de pan derivadas de la jerarquía real de categorías del producto.',
+  },
+  ProductOverview: {
+    props: productOverviewPropsSchema,
+    description: 'Detalle de producto: galería, precio, variantes y añadir al carrito.',
+  },
+  Reviews: {
+    props: reviewsPropsSchema,
+    description: 'Opiniones de clientes con resumen de valoración.',
+  },
+}
+
+const hasNavigability = mountedFeatureNames.includes('navigability')
+
+// Entity-derived trail only: the product's real ancestor categories. When the
+// feature is absent or the backend supplies no category, the trail is empty and
+// the Breadcrumb block renders nothing (no level is ever invented).
+function resolveProductBreadcrumbItems(
+  title: string,
+  categoryPath: { handle: string; name: string }[] | undefined,
+): { label: string; href?: string }[] {
+  if (!hasNavigability || !categoryPath || categoryPath.length === 0) return []
+  const chain = categoryPath.map((entry) => ({
+    label: entry.name,
+    href: `/categories/${entry.handle}`,
+  }))
+  // Home > ancestor categories (links) > the product itself (current page).
+  return [{ label: 'Inicio', href: '/' }, ...chain, { label: title }]
+}
+
+export const product: ViewModule = {
+  name: 'product',
+  elements,
+  catalog,
+  registry,
+  route: {
+    path: '/products/[id]',
+    loaderName: 'product',
+    layout: 'default',
+    metadata: {
+      title: 'Producto',
+      description: 'Detalles del producto seleccionado.',
+    },
+    entry: pageRoot(
+      'product',
+      ['product.breadcrumb', 'product.overview', 'product.reviews'],
+      elements,
+    ),
+  },
+  loader: {
+    product: async (params) => {
+      const handle = Array.isArray(params.id) ? params.id[0] : params.id
+      const dataSource = getDataSource()
+
+      let result: Awaited<ReturnType<typeof loadProductDetail>>
+      try {
+        result = await loadProductDetail(String(handle))
+      } catch (error) {
+        // A real data-source failure is surfaced visibly (never demo data).
+        return {
+          selectedProduct: null,
+          selectedVariantId: null,
+          productQuantity: 1,
+          productReviews: [],
+          hasProductReviews: false,
+          breadcrumbItems: [],
+          dataSource,
+          dataError:
+            error instanceof Error ? error.message : 'No se pudo cargar el producto.',
+        }
+      }
+
+      // An unknown handle is a real 404 (the catch-all page renders not-found);
+      // it is never a demo product.
+      if (!result.detail) notFound()
+
+      return {
+        selectedProduct: buildSelectedProduct(result.detail),
+        // No first-variant shortcut on the detail surface: the shopper must
+        // select explicitly (listing cards use the card shortcut instead).
+        selectedVariantId: initialSelectedVariantId(),
+        productQuantity: 1,
+        productReviews: [],
+        hasProductReviews: false,
+        breadcrumbItems: resolveProductBreadcrumbItems(
+          result.detail.title,
+          result.detail.categoryPath,
+        ),
+        dataSource: result.source,
+        dataError: null,
+      }
+    },
+  },
+}

package/assets/templates/views/product/props.ts

@@ -0,0 +1,27 @@
+// Thor Commerce view props: product
+// User-owned element props for the product view. Reconcile seeds this file once
+// and never rewrites it; the derived view module (./index.tsx) imports these
+// objects and binds them into the element tree, so edits here survive
+// `storefront sync` and unit removal. Plain data only: no React and no server
+// imports.
+
+import { productLabels, reviewsCopy } from './content'
+
+export const productOverviewProps = {
+  ...productLabels,
+  product: { $state: '/selectedProduct' },
+  selectedVariantId: { $state: '/selectedVariantId' },
+  quantity: { $state: '/productQuantity' },
+}
+
+export const productReviewsProps = {
+  ...reviewsCopy,
+  reviews: { $state: '/productReviews' },
+}
+
+// Presentational defaults only; the entity-derived trail is bound to
+// `$state: '/productBreadcrumbItems'` in the element tree, never invented here.
+export const productBreadcrumbProps = {
+  ariaLabel: 'Migas de pan',
+  backLabel: 'Volver',
+}

package/assets/templates/views/product/registry.tsx

@@ -0,0 +1,103 @@
+'use client'
+
+// Thor Commerce view registry fragment: product
+// Client boundary for the product view. Imports value bindings from
+// @json-render/react and components from @thorprovider/blocks — both must stay
+// on the client side of the RSC graph. Kept separate from index.tsx so the view
+// spec (elements/catalog/route/loader) stays a pure Server Component module.
+
+import {
+  Breadcrumb as BreadcrumbBlock,
+  ProductOverview1 as ProductOverviewBlock,
+  ReviewRating1 as ReviewsBlock,
+} from '@thorprovider/blocks'
+import { isAvailableMoney } from '@thorprovider/blocks/contracts'
+import { useStateStore } from '@json-render/react'
+import { useProductVisitObservation } from '../../section-observation'
+import type { ViewRegistry } from '../types'
+import { productOverviewPropsSchema, reviewsPropsSchema } from './schema'
+
+export const registry: ViewRegistry = {
+  Breadcrumb: ({ props }) => {
+    const p = props as {
+      items: { label: string; href?: string }[]
+      maxItems?: number
+      ariaLabel?: string
+      backLabel?: string
+      className?: string
+    }
+    return (
+      <BreadcrumbBlock
+        items={p.items}
+        maxItems={p.maxItems}
+        ariaLabel={p.ariaLabel}
+        backLabel={p.backLabel}
+        className={p.className}
+      />
+    )
+  },
+  ProductOverview: ({ props, emit }) => {
+    const { set } = useStateStore()
+    const parsed = productOverviewPropsSchema.parse(props)
+    // A successfully rendered product destination: recorded only when it matches
+    // the section origin (disabled by default; never attributes a guess). The
+    // stable public identity is the handle, which is what section clicks record.
+    const productHandle = parsed.product.handle ?? parsed.product.id
+    useProductVisitObservation(productHandle, `/products/${productHandle}`)
+    return (
+      <ProductOverviewBlock
+        product={parsed.product}
+        selectedVariantId={parsed.selectedVariantId ?? null}
+        quantity={parsed.quantity}
+        sizesLabel={parsed.sizesLabel}
+        variantLabel={parsed.variantLabel}
+        reviewsLabel={parsed.reviewsLabel}
+        addToCartLabel={parsed.addToCartLabel}
+        outOfStockLabel={parsed.outOfStockLabel}
+        unavailablePriceLabel={parsed.unavailablePriceLabel}
+        selectVariantLabel={parsed.selectVariantLabel}
+        quantityLabel={parsed.quantityLabel}
+        onSelectVariant={(variantId) => {
+          set('/selectedVariantId', variantId)
+        }}
+        onQuantityChange={(quantity) => {
+          set('/productQuantity', quantity)
+        }}
+        onAddToCart={(variantId, quantity) => {
+          // Preserve the selected backend variant id and quantity the block
+          // emits — the handler must never drop them or substitute the SKU.
+          const variant = parsed.product.variants.find((candidate) => candidate.id === variantId)
+          const price = isAvailableMoney(variant?.price) ? Number(variant.price.amount) : 0
+          set('/lastAddToCart', {
+            variantId,
+            quantity,
+            name: parsed.product.title,
+            variant: variant?.title ?? '',
+            price,
+            image: variant?.image?.url ?? parsed.product.featuredImage?.url,
+          })
+          emit('addToCart')
+        }}
+        onToggleWishlist={() => {}}
+      />
+    )
+  },
+  Reviews: ({ props, emit }) => {
+    const parsed = reviewsPropsSchema.parse(props)
+    return (
+      <ReviewsBlock
+        pageTitle={parsed.pageTitle}
+        pageDescription={parsed.pageDescription}
+        reviews={parsed.reviews}
+        form={parsed.form}
+        reviewsPerPage={parsed.reviewsPerPage}
+        onToggleReviewLike={() => {
+          emit('toggleReviewLike')
+        }}
+        onSubmitReview={() => {
+          emit('submitReview')
+        }}
+      />
+    )
+  },
+}

package/assets/templates/views/product/schema.ts

@@ -0,0 +1,121 @@
+// Thor Commerce view schema fragment: product
+// Zod mirrors of the block contracts for this view — the single source for the
+// catalog entries and the client-side registry parsing (json-render does not
+// validate props against the catalog itself, so the registry parses here).
+// Kept free of React and server imports so the Server Component module and the
+// 'use client' registry can share one contract. Block zod contracts are
+// mirrored, not imported: @thorprovider/blocks ships zod v3 while the scaffold
+// runs zod v4 and cross-major schema assignment breaks the catalog contract.
+
+import { z } from 'zod'
+
+const imageSchema = z.object({
+  id: z.string().optional(),
+  url: z.string(),
+  altText: z.string(),
+  width: z.number().optional(),
+  height: z.number().optional(),
+})
+
+// Canonical Money: a decimal string in major units ("69.99"), never cents.
+const moneySchema = z.object({
+  amount: z.string(),
+  currencyCode: z.string(),
+})
+
+const selectedOptionSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+})
+
+// Mirrors ProductDetailVariant: `price` is absent/null when the backend has no
+// resolved price (the block disables purchase); a valid zero stays "0".
+const productDetailVariantSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  sku: z.string().optional(),
+  availableForSale: z.boolean(),
+  selectedOptions: z.array(selectedOptionSchema),
+  price: moneySchema.nullish(),
+  compareAtPrice: moneySchema.optional(),
+  image: imageSchema.optional(),
+})
+
+// Mirrors ProductDetailProduct (the ProductOverview1 block contract).
+export const productDetailProductSchema = z.object({
+  id: z.string(),
+  handle: z.string().optional(),
+  title: z.string(),
+  description: z.string().optional(),
+  vendor: z.string().optional(),
+  options: z.array(z.object({ id: z.string(), name: z.string(), values: z.array(z.string()) })),
+  variants: z.array(productDetailVariantSchema),
+  images: z.array(imageSchema),
+  featuredImage: imageSchema.optional(),
+})
+
+export const productOverviewPropsSchema = z.object({
+  product: productDetailProductSchema,
+  selectedVariantId: z.string().nullable().optional(),
+  quantity: z.number().optional(),
+  sizesLabel: z.string().optional(),
+  variantLabel: z.string().optional(),
+  reviewsLabel: z.string().optional(),
+  addToCartLabel: z.string().optional(),
+  outOfStockLabel: z.string().optional(),
+  unavailablePriceLabel: z.string().optional(),
+  selectVariantLabel: z.string().optional(),
+  quantityLabel: z.string().optional(),
+})
+
+// Mirrors ReviewRating1Review (real reviews only; never seeded).
+export const reviewSchema = z.object({
+  id: z.number(),
+  userName: z.string(),
+  userAvatar: z.string().optional(),
+  date: z.string(),
+  rating: z.number(),
+  content: z.string(),
+  likes: z.number().optional(),
+  comments: z.number().optional(),
+})
+
+export const reviewFormSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  nameLabel: z.string(),
+  emailLabel: z.string(),
+  reviewLabel: z.string(),
+  namePlaceholder: z.string(),
+  emailPlaceholder: z.string(),
+  reviewPlaceholder: z.string(),
+  submitButtonText: z.string(),
+  submittingButtonText: z.string(),
+})
+
+export const reviewsPropsSchema = z.object({
+  pageTitle: z.string(),
+  pageDescription: z.string().optional(),
+  reviews: z.array(reviewSchema),
+  form: reviewFormSchema.optional(),
+  reviewsPerPage: z.number().optional(),
+})
+
+export const breadcrumbItemSchema = z.object({
+  label: z.string(),
+  href: z.string().optional(),
+})
+
+export const breadcrumbPropsSchema = z.object({
+  items: z.array(breadcrumbItemSchema),
+  maxItems: z.number().int().min(2).optional(),
+  ariaLabel: z.string().optional(),
+  backLabel: z.string().optional(),
+  className: z.string().optional(),
+})
+
+export type ProductDetailProductSpec = z.infer<typeof productDetailProductSchema>
+export type ProductOverviewProps = z.infer<typeof productOverviewPropsSchema>
+export type Review = z.infer<typeof reviewSchema>
+export type ReviewForm = z.infer<typeof reviewFormSchema>
+export type ReviewsProps = z.infer<typeof reviewsPropsSchema>

package/assets/templates/views/static/content.ts

@@ -0,0 +1,99 @@
+// Thor Commerce view content: static
+// User-owned content — reconcile seeds this file once and never rewrites it, so
+// your edits survive `storefront sync`. Declare the pages this store serves and
+// the ordered sections each one renders. The derived view builds one fixed route
+// per declared page, so an undeclared path falls through to the not-found
+// response.
+//
+// Neutral, truthful copy only: these pages make no delivery, shipping, or price
+// promise and invent no company facts. Replace the copy with your own before
+// publishing.
+
+import type { StaticPageContent } from './schema'
+
+export const staticPagesContent: StaticPageContent[] = [
+  {
+    path: '/contact',
+    title: 'Contacto',
+    description: 'Cómo comunicarte con la tienda.',
+    sections: [
+      { kind: 'heading', text: 'Contacto' },
+      {
+        kind: 'paragraph',
+        text: 'Esta tienda atiende en línea. Usa los canales de atención que la tienda publique para resolver tus dudas sobre productos, pedidos y pagos.',
+      },
+      {
+        kind: 'list',
+        items: [
+          'Consulta el estado de tu pedido desde tu cuenta.',
+          'Escríbenos por el canal de atención que la tienda publique.',
+          'Revisa las preguntas frecuentes antes de escribirnos.',
+        ],
+      },
+    ],
+  },
+  {
+    path: '/terms',
+    title: 'Términos y condiciones',
+    description: 'Condiciones de uso de la tienda en línea.',
+    sections: [
+      { kind: 'heading', text: 'Términos y condiciones' },
+      {
+        kind: 'paragraph',
+        text: 'Al usar esta tienda en línea aceptas estas condiciones de uso. Léelas con atención antes de realizar una compra.',
+      },
+      {
+        kind: 'paragraph',
+        text: 'La tienda puede actualizar estos términos para reflejar cambios en el servicio. La versión vigente es la publicada en esta página.',
+      },
+      {
+        kind: 'list',
+        items: [
+          'Usa la tienda de forma lícita y con información veraz.',
+          'El catálogo, los precios y la disponibilidad se muestran en la tienda y pueden cambiar.',
+          'El proceso de compra se completa siguiendo los pasos indicados en el sitio.',
+        ],
+      },
+    ],
+  },
+  {
+    path: '/privacy',
+    title: 'Política de privacidad',
+    description: 'Cómo se tratan los datos en la tienda en línea.',
+    sections: [
+      { kind: 'heading', text: 'Política de privacidad' },
+      {
+        kind: 'paragraph',
+        text: 'Esta política describe cómo la tienda trata la información que proporcionas al navegar y al comprar.',
+      },
+      {
+        kind: 'paragraph',
+        text: 'Usamos tus datos para gestionar tu cuenta, procesar tus pedidos y darte soporte. No los usamos para fines distintos sin tu consentimiento.',
+      },
+      {
+        kind: 'list',
+        items: [
+          'Proporciona solo la información necesaria para completar tu compra.',
+          'Puedes solicitar la actualización o eliminación de tus datos por los canales de atención.',
+          'Conserva tus credenciales de acceso de forma segura.',
+        ],
+      },
+    ],
+  },
+  {
+    path: '/about',
+    title: 'Sobre nosotros',
+    description: 'Información sobre la tienda.',
+    sections: [
+      { kind: 'heading', text: 'Sobre nosotros' },
+      {
+        kind: 'paragraph',
+        text: 'Somos una tienda en línea que ofrece un catálogo de productos para tu hogar y tu negocio.',
+      },
+      {
+        kind: 'paragraph',
+        text: 'Trabajamos para que encuentres lo que buscas y para acompañarte durante todo el proceso de compra a través de esta tienda.',
+      },
+    ],
+  },
+]