feat(carousel): enhance product list layout with adaptive grid and simple vertical options

src/app/core/services/auth/auth.service.spec.ts

@@ -6,6 +6,7 @@ import { HttpTestingController, provideHttpClientTesting } from '@angular/common
 import { environment } from '../../../../environments/environment';
 import { AuthService } from './auth.service';
 import { CookieService } from '../cookie/cookie.service';
+import { TenantService } from '../tenant.service';
 
 describe('AuthService', () => {
   let cookieStore: Record<string, string> = {};
@@ -95,7 +96,7 @@ describe('AuthService', () => {
     httpController.verify();
   });
 
-  it('propagates a 401 from /me without clearing the session', async () => {
+  it('clears an expired session when /me returns 401', async () => {
     cookieStore['shopit.auth.token'] = 'expired-token';
 
     TestBed.configureTestingModule({
@@ -116,11 +117,11 @@ describe('AuthService', () => {
 
     request.flush({ message: 'Unauthorized' }, { status: 401, statusText: 'Unauthorized' });
 
-    await expect(bootstrapPromise).rejects.toMatchObject({ status: 401 });
+    await expect(bootstrapPromise).resolves.toBeUndefined();
     expect(service.user()).toBeNull();
-    expect(service.token()).toBe('expired-token');
-    expect(service.isAuthenticated()).toBe(true);
-    expect(cookieStore['shopit.auth.token']).toBe('expired-token');
+    expect(service.token()).toBeNull();
+    expect(service.isAuthenticated()).toBe(false);
+    expect(cookieStore['shopit.auth.token']).toBeUndefined();
 
     httpController.verify();
   });
@@ -132,6 +133,10 @@ describe('AuthService', () => {
         provideHttpClientTesting(),
         AuthService,
         { provide: CookieService, useValue: createCookieServiceStub() },
+        {
+          provide: TenantService,
+          useValue: { getTenant: () => ({ codigo: 'tenant-test' }) }
+        },
         TransferState
       ]
     });
@@ -152,6 +157,7 @@ describe('AuthService', () => {
 
     const request = httpController.expectOne(`${environment.url}register`);
     expect(request.request.method).toBe('POST');
+    expect(request.request.body.tenant_codigo).toBe('tenant-test');
     request.flush({
       message: 'Usuario registrado correctamente.',
       data: {

src/app/core/services/auth/auth.service.ts

@@ -1,4 +1,5 @@
-import { HttpClient } from '@angular/common/http';
+import { DOCUMENT } from '@angular/common';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
 import { computed, inject, Injectable, PLATFORM_ID, signal, TransferState, makeStateKey } from '@angular/core';
 import { firstValueFrom, map, Observable, of, tap } from 'rxjs';
@@ -13,6 +14,7 @@ import {
   UpdateProfilePayload
 } from './auth.interfaces';
 import { CookieService } from '../cookie/cookie.service';
+import { TenantService } from '../tenant.service';
 
 const AUTH_TOKEN_COOKIE_KEY = 'shopit.auth.token';
 const AUTH_USER_SSR_STATE_KEY = makeStateKey<AuthUser>('shopit.auth.user');
@@ -22,9 +24,11 @@ const AUTH_USER_SSR_STATE_KEY = makeStateKey<AuthUser>('shopit.auth.user');
 })
 export class AuthService {
   private readonly http = inject(HttpClient);
+  private readonly document = inject(DOCUMENT);
   private readonly platformId = inject(PLATFORM_ID);
   private readonly cookieService = inject(CookieService);
   private readonly transferState = inject(TransferState);
+  private readonly tenantService = inject(TenantService);
 
   private readonly userState = signal<AuthUser | null>(null);
   private readonly tokenState = signal<string | null>(null);
@@ -41,7 +45,33 @@ export class AuthService {
   }
 
   register(payload: RegisterPayload): Observable<RegisterResponse> {
-    return this.http.post<RegisterResponse>(`${environment.url}register`, payload);
+    const tenantCode = this.tenantService.getTenant()?.codigo;
+
+    return this.http.post<RegisterResponse>(`${environment.url}register`, {
+      ...payload,
+      ...(tenantCode ? { tenant_codigo: tenantCode } : {})
+    });
+  }
+
+  loginWithGoogle(): void {
+    const tenant = this.tenantService.getTenant();
+    if (!tenant) {
+      throw new Error('No se pudo resolver el tenant activo.');
+    }
+
+    const apiUrl = new URL(environment.url);
+    const authorizationUrl = new URL('/auth/google/redirect', apiUrl.origin);
+    authorizationUrl.searchParams.set('tenant', tenant.codigo);
+    authorizationUrl.searchParams.set('return_url', this.document.location.origin);
+
+    this.document.location.assign(authorizationUrl.toString());
+  }
+
+  completeGoogleLogin(oauthCode: string): Observable<AuthUser> {
+    return this.http.post<LoginResponse>(`${environment.url}auth/google/exchange`, { oauth_code: oauthCode }).pipe(
+      tap((response) => this.applyAuthenticatedState(response.token, response.user)),
+      map((response) => response.user)
+    );
   }
 
   updateProfile(payload: UpdateProfilePayload): Observable<AuthUser> {
@@ -75,9 +105,24 @@ export class AuthService {
       return;
     }
 
-    const user = await firstValueFrom(this.loadCurrentUser());
-    if (isPlatformServer(this.platformId)) {
-      this.transferState.set(AUTH_USER_SSR_STATE_KEY, user);
+    try {
+      const user = await firstValueFrom(this.loadCurrentUser());
+
+      if (isPlatformServer(this.platformId)) {
+        this.transferState.set(AUTH_USER_SSR_STATE_KEY, user);
+      }
+    } catch (error) {
+      // An expired token is an expected state, including while rendering on the
+      // server. Do not let it reject the application initializer: Angular's SSR
+      // pipeline can otherwise attempt to serialize HttpErrorResponse internals
+      // as HTTP headers.
+      if (error instanceof HttpErrorResponse && error.status === 401) {
+        this.clearSession();
+
+        return;
+      }
+
+      throw error;
     }
   }
 

src/app/core/services/catalog/catalog.interface.ts

@@ -65,6 +65,7 @@ export interface CatalogItemDetail {
 }
 
 export type CatalogProductLayout = 'row' | 'column_with_image' | 'column_with_cart';
+export type CatalogGroupLayout = 'paginated' | 'simple' | 'simple_vertical' | 'carousel';
 
 export interface CatalogFeaturedItemVariant {
   id: number;
@@ -82,10 +83,14 @@ export interface CatalogFeaturedItem {
   variants?: CatalogFeaturedItemVariant[];
 }
 
+export type CatalogFeaturedItems =
+  ApiPaginatedResponse<CatalogFeaturedItem[]> | CatalogFeaturedItem[];
+
 export interface CatalogFeaturedGroup {
   id: number;
   title: string;
   layout: CatalogProductLayout;
+  group_layout: CatalogGroupLayout;
   group_order: number;
-  items: ApiPaginatedResponse<CatalogFeaturedItem[]>;
+  items: CatalogFeaturedItems;
 }

src/app/core/services/catalog/catalog.service.ts

@@ -8,7 +8,7 @@ import { ApiResponse } from '../api-response.interface';
 import { TenantService } from '../tenant.service';
 import {
   CatalogFeaturedGroup,
-  CatalogFeaturedItem,
+  CatalogFeaturedItems,
   CatalogItemDetail,
   Product,
 } from './catalog.interface';
@@ -39,8 +39,8 @@ export class CatalogService {
   getFeaturedGroupItems(
     featuredGroupId: number,
     params?: ApiPaginationQueryParams,
-  ): Observable<ApiPaginatedResponse<CatalogFeaturedItem[]>> {
-    return this.http.get<ApiPaginatedResponse<CatalogFeaturedItem[]>>(
+  ): Observable<CatalogFeaturedItems> {
+    return this.http.get<CatalogFeaturedItems>(
       `${this.tenantApiUrl}/catalog/featured-groups/${featuredGroupId}/items`,
       { params: this.buildHttpParams(params) },
     );

src/app/features/componentes-test/pages/reutilizables-test-page/reutilizables-test-page.component.html

@@ -574,6 +574,41 @@
     </div>
   </section>
 
+  <section class="component-demo card shadow-sm mt-4" data-testid="products-carousel">
+    <div class="card-body">
+      <span class="eyebrow">Reusable Component</span>
+      <h2 class="mb-3">Carousel de productos</h2>
+
+      <p class="text-muted mb-4">
+        El carousel controla únicamente el desplazamiento. Cada ítem se define externamente con un
+        template y en este ejemplo renderiza productos con imágenes mockeadas.
+      </p>
+
+      <ng-template #productCarouselItem let-product let-index="index">
+        <div class="carousel-product" [attr.data-carousel-index]="index">
+          <span class="carousel-product__mock-id">ITEM {{ product.id }}</span>
+          <app-product-column-with-image
+            [imageUrl]="product.imageUrl"
+            [title]="product.title"
+            [originalPrice]="product.originalPrice"
+            [discount]="product.discount"
+            [transferPrice]="product.transferPrice"
+            (buy)="onProductBuy(product.title)"
+          />
+        </div>
+      </ng-template>
+
+      <app-carousel
+        [items]="carouselProducts"
+        [itemTemplate]="productCarouselItem"
+        [trackBy]="trackCarouselProduct"
+        [gap]="16"
+        [circular]="true"
+        ariaLabel="Productos con imágenes de prueba"
+      />
+    </div>
+  </section>
+
   <section class="component-demo card shadow-sm mt-4">
     <div class="card-body">
       <span class="eyebrow">Reusable Component</span>

src/app/features/componentes-test/pages/reutilizables-test-page/reutilizables-test-page.component.scss

@@ -19,6 +19,32 @@
   width: min(100%, 64rem);
 }
 
+.carousel-product {
+  position: relative;
+  width: clamp(15rem, 30vw, 18rem);
+  height: 100%;
+
+  &__mock-id {
+    position: absolute;
+    top: 0.75rem;
+    left: 0.75rem;
+    z-index: 2;
+    padding: 0.35rem 0.55rem;
+    color: #fff;
+    font-size: 0.7rem;
+    font-weight: 700;
+    line-height: 1;
+    letter-spacing: 0.08em;
+    background: rgb(20 20 20 / 82%);
+    border-radius: 999px;
+  }
+
+  app-product-column-with-image {
+    display: block;
+    height: 100%;
+  }
+}
+
 .eyebrow {
   display: inline-block;
   margin-bottom: 0.75rem;
@@ -155,7 +181,6 @@ h1 {
   gap: 0.75rem;
 }
 
-
 .file-field {
   display: grid;
   gap: 0.75rem;
@@ -168,6 +193,10 @@ h1 {
 }
 
 @media (max-width: 767.98px) {
+  .carousel-product {
+    width: min(18rem, calc(100vw - 5rem));
+  }
+
   .input-grid {
     grid-template-columns: minmax(0, 1fr);
   }
@@ -206,11 +235,15 @@ h1 {
       padding: 1rem;
       overflow: hidden;
       box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.05);
-      transition: transform 0.2s ease, box-shadow 0.2s ease;
+      transition:
+        transform 0.2s ease,
+        box-shadow 0.2s ease;
 
       &:hover {
         transform: translateY(-2px);
-        box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.05), 0 4px 12px rgba(0, 0, 0, 0.08);
+        box-shadow:
+          inset 0 2px 4px rgba(0, 0, 0, 0.05),
+          0 4px 12px rgba(0, 0, 0, 0.08);
       }
     }
 
@@ -251,7 +284,9 @@ h1 {
     border: 1px solid #dee2e6;
     overflow: hidden;
     background-color: #ffffff;
-    transition: transform 0.2s ease, box-shadow 0.2s ease;
+    transition:
+      transform 0.2s ease,
+      box-shadow 0.2s ease;
 
     &:hover {
       transform: translateY(-3px);

src/app/features/componentes-test/pages/reutilizables-test-page/reutilizables-test-page.component.spec.ts

@@ -1,9 +1,6 @@
 import { signal } from '@angular/core';
 import { TestBed, getTestBed } from '@angular/core/testing';
-import {
-  BrowserTestingModule,
-  platformBrowserTesting
-} from '@angular/platform-browser/testing';
+import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-browser/testing';
 import { of } from 'rxjs';
 import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 
@@ -25,7 +22,7 @@ const tenant: Tenant = {
   header_bg_color: '#313131',
   footer_bg_color: '#313131',
   header_logo: 'https://example.com/header.png',
-  footer_logo: 'https://example.com/footer.png'
+  footer_logo: 'https://example.com/footer.png',
 };
 
 function createTenantServiceStub(currentTenant: Tenant | null) {
@@ -36,7 +33,7 @@ function createTenantServiceStub(currentTenant: Tenant | null) {
     tenant: tenantState.asReadonly(),
     status: statusState.asReadonly(),
     getTenant: () => tenantState(),
-    bootstrap: vi.fn().mockResolvedValue(undefined)
+    bootstrap: vi.fn().mockResolvedValue(undefined),
   };
 }
 
@@ -44,7 +41,7 @@ function createToastServiceStub() {
   return {
     success: vi.fn(),
     danger: vi.fn(),
-    info: vi.fn()
+    info: vi.fn(),
   };
 }
 
@@ -52,17 +49,14 @@ function createModalServiceStub() {
   return {
     open: vi.fn(),
     openConfirm: vi.fn().mockReturnValue(of(true)),
-    openConfirmDelete: vi.fn().mockReturnValue(of(false))
+    openConfirmDelete: vi.fn().mockReturnValue(of(false)),
   };
 }
 
 describe('ReutilizablesTestPageComponent', () => {
   beforeAll(() => {
     try {
-      getTestBed().initTestEnvironment(
-        BrowserTestingModule,
-        platformBrowserTesting()
-      );
+      getTestBed().initTestEnvironment(BrowserTestingModule, platformBrowserTesting());
     } catch {
       // Test environment may already be initialized by another setup entrypoint.
     }
@@ -79,17 +73,17 @@ describe('ReutilizablesTestPageComponent', () => {
       providers: [
         {
           provide: TenantService,
-          useValue: createTenantServiceStub(tenant)
+          useValue: createTenantServiceStub(tenant),
         },
         {
           provide: ToastService,
-          useValue: createToastServiceStub()
+          useValue: createToastServiceStub(),
         },
         {
           provide: ModalService,
-          useValue: modalServiceStub
-        }
-      ]
+          useValue: modalServiceStub,
+        },
+      ],
     }).compileComponents();
 
     const fixture = TestBed.createComponent(ReutilizablesTestPageComponent);
@@ -101,12 +95,12 @@ describe('ReutilizablesTestPageComponent', () => {
     expect(sectionTitle?.textContent).toContain('Configuracion Tenant');
 
     const headerImg = element.querySelector(
-      '.tenant-logo-card img[alt="Header Logo"]'
+      '.tenant-logo-card img[alt="Header Logo"]',
     ) as HTMLImageElement;
     expect(headerImg?.src).toBe(tenant.header_logo);
 
     const footerImg = element.querySelector(
-      '.tenant-logo-card img[alt="Footer Logo"]'
+      '.tenant-logo-card img[alt="Footer Logo"]',
     ) as HTMLImageElement;
     expect(footerImg?.src).toBe(tenant.footer_logo);
 
@@ -123,17 +117,17 @@ describe('ReutilizablesTestPageComponent', () => {
       providers: [
         {
           provide: TenantService,
-          useValue: createTenantServiceStub(tenant)
+          useValue: createTenantServiceStub(tenant),
         },
         {
           provide: ToastService,
-          useValue: createToastServiceStub()
+          useValue: createToastServiceStub(),
         },
         {
           provide: ModalService,
-          useValue: modalServiceStub
-        }
-      ]
+          useValue: modalServiceStub,
+        },
+      ],
     }).compileComponents();
 
     const fixture = TestBed.createComponent(ReutilizablesTestPageComponent);
@@ -142,9 +136,48 @@ describe('ReutilizablesTestPageComponent', () => {
     const element = fixture.nativeElement as HTMLElement;
 
     expect(element.querySelector('app-paginator')).not.toBeNull();
+    expect(element.querySelector('[data-testid="paginator-status"]')?.textContent?.trim()).toBe(
+      '1/8',
+    );
+  });
+
+  it('renders the carousel demo with mocked product images', async () => {
+    await TestBed.configureTestingModule({
+      imports: [ReutilizablesTestPageComponent],
+      providers: [
+        {
+          provide: TenantService,
+          useValue: createTenantServiceStub(tenant),
+        },
+        {
+          provide: ToastService,
+          useValue: createToastServiceStub(),
+        },
+        {
+          provide: ModalService,
+          useValue: createModalServiceStub(),
+        },
+      ],
+    }).compileComponents();
+
+    const fixture = TestBed.createComponent(ReutilizablesTestPageComponent);
+    fixture.detectChanges();
+
+    const element = fixture.nativeElement as HTMLElement;
+    const carouselDemo = element.querySelector('[data-testid="products-carousel"]');
+    const carouselItems = carouselDemo?.querySelectorAll('[data-carousel-index]');
+    const productImages = carouselDemo?.querySelectorAll('app-product-column-with-image img');
+
+    expect(carouselDemo?.querySelector('app-carousel')).not.toBeNull();
+    expect(carouselItems).toHaveLength(6);
+    expect(productImages).toHaveLength(6);
+    expect(productImages?.[0].getAttribute('src')).toContain('/images/carousel-mochila-roja.webp');
+    expect(productImages?.[1].getAttribute('src')).toContain(
+      '/images/carousel-auriculares-amarillos.webp',
+    );
     expect(
-      element.querySelector('[data-testid="paginator-status"]')?.textContent?.trim()
-    ).toBe('1/8');
+      new Set(Array.from(productImages ?? [], (image) => image.getAttribute('src'))).size,
+    ).toBe(6);
   });
 
   it('renders the modal showcase and opens the confirm demos from the buttons', async () => {
@@ -154,36 +187,34 @@ describe('ReutilizablesTestPageComponent', () => {
       providers: [
         {
           provide: TenantService,
-          useValue: createTenantServiceStub(tenant)
+          useValue: createTenantServiceStub(tenant),
         },
         {
           provide: ToastService,
-          useValue: createToastServiceStub()
+          useValue: createToastServiceStub(),
         },
         {
           provide: ModalService,
-          useValue: modalServiceStub
-        }
-      ]
+          useValue: modalServiceStub,
+        },
+      ],
     }).compileComponents();
 
     const fixture = TestBed.createComponent(ReutilizablesTestPageComponent);
     fixture.detectChanges();
 
     const element = fixture.nativeElement as HTMLElement;
-    const buttons = Array.from(
-      element.querySelectorAll('.button-group app-button button')
-    );
+    const buttons = Array.from(element.querySelectorAll('.button-group app-button button'));
     const confirmButton = buttons.find((button) =>
-      button.textContent?.includes('Abrir confirm modal')
+      button.textContent?.includes('Abrir confirm modal'),
     ) as HTMLButtonElement;
     const deleteButton = buttons.find((button) =>
-      button.textContent?.includes('Abrir confirm delete')
+      button.textContent?.includes('Abrir confirm delete'),
     ) as HTMLButtonElement;
 
-    expect(
-      element.querySelector('[data-testid="modal-last-result"]')?.textContent
-    ).toContain('Todavia no se abrio ningun modal.');
+    expect(element.querySelector('[data-testid="modal-last-result"]')?.textContent).toContain(
+      'Todavia no se abrio ningun modal.',
+    );
 
     confirmButton.click();
     fixture.detectChanges();
@@ -193,17 +224,17 @@ describe('ReutilizablesTestPageComponent', () => {
     expect(modalServiceStub.openConfirm).toHaveBeenCalledWith({
       title: 'Confirmar accion',
       content: 'Caso base para verificar apertura, cierre y devolucion de resultado.',
-      confirmLabel: 'Confirmar'
+      confirmLabel: 'Confirmar',
     });
     expect(modalServiceStub.openConfirmDelete).toHaveBeenCalledWith({
       title: 'Eliminar producto',
       content:
         'Esta accion eliminara el producto del catalogo. Podras volver a crearlo manualmente.',
-      confirmLabel: 'Eliminar'
+      confirmLabel: 'Eliminar',
     });
-    expect(
-      element.querySelector('[data-testid="modal-last-result"]')?.textContent
-    ).toContain('Resultado: false');
+    expect(element.querySelector('[data-testid="modal-last-result"]')?.textContent).toContain(
+      'Resultado: false',
+    );
   });
 
   it('updates the visible result when the confirm modal resolves to true', async () => {
@@ -213,17 +244,17 @@ describe('ReutilizablesTestPageComponent', () => {
       providers: [
         {
           provide: TenantService,
-          useValue: createTenantServiceStub(tenant)
+          useValue: createTenantServiceStub(tenant),
         },
         {
           provide: ToastService,
-          useValue: createToastServiceStub()
+          useValue: createToastServiceStub(),
         },
         {
           provide: ModalService,
-          useValue: modalServiceStub
-        }
-      ]
+          useValue: modalServiceStub,
+        },
+      ],
     }).compileComponents();
 
     const fixture = TestBed.createComponent(ReutilizablesTestPageComponent);
@@ -231,16 +262,14 @@ describe('ReutilizablesTestPageComponent', () => {
 
     const element = fixture.nativeElement as HTMLElement;
     const confirmButton = Array.from(
-      element.querySelectorAll('.button-group app-button button')
-    ).find((button) =>
-      button.textContent?.includes('Abrir confirm modal')
-    ) as HTMLButtonElement;
+      element.querySelectorAll('.button-group app-button button'),
+    ).find((button) => button.textContent?.includes('Abrir confirm modal')) as HTMLButtonElement;
 
     confirmButton.click();
     fixture.detectChanges();
 
-    expect(
-      element.querySelector('[data-testid="modal-last-result"]')?.textContent
-    ).toContain('Resultado: true');
+    expect(element.querySelector('[data-testid="modal-last-result"]')?.textContent).toContain(
+      'Resultado: true',
+    );
   });
 });

src/app/features/componentes-test/pages/reutilizables-test-page/reutilizables-test-page.component.ts

@@ -14,6 +14,16 @@ import { TenantService } from '../../../../core/services/tenant.service';
 import { ToastService } from '../../../../core/services/toast.service';
 import { StepperComponent } from '../../../../shared/components/stepper/stepper.component';
 import { StepComponent } from '../../../../shared/components/stepper/step.component';
+import { CarouselComponent } from '../../../../shared/components/carousel/carousel.component';
+
+interface CarouselProductMock {
+  id: number;
+  title: string;
+  originalPrice: number;
+  discount: number | null;
+  transferPrice: number;
+  imageUrl: string;
+}
 
 @Component({
   selector: 'app-reutilizables-test-page',
@@ -30,6 +40,7 @@ import { StepComponent } from '../../../../shared/components/stepper/step.compon
     CartIconComponent,
     StepperComponent,
     StepComponent,
+    CarouselComponent,
   ],
   templateUrl: './reutilizables-test-page.component.html',
   styleUrl: './reutilizables-test-page.component.scss',
@@ -87,6 +98,62 @@ export class ReutilizablesTestPageComponent {
     },
   ];
 
+  protected readonly carouselProducts: CarouselProductMock[] = [
+    {
+      id: 1,
+      title: '01 · Mochila roja',
+      originalPrice: 85000,
+      discount: 20,
+      transferPrice: 68000,
+      imageUrl: '/images/carousel-mochila-roja.webp',
+    },
+    {
+      id: 2,
+      title: '02 · Auriculares amarillos',
+      originalPrice: 120000,
+      discount: 15,
+      transferPrice: 102000,
+      imageUrl: '/images/carousel-auriculares-amarillos.webp',
+    },
+    {
+      id: 3,
+      title: '03 · Reloj verde',
+      originalPrice: 96000,
+      discount: 10,
+      transferPrice: 86400,
+      imageUrl: '/images/carousel-reloj-verde.webp',
+    },
+    {
+      id: 4,
+      title: '04 · Cámara violeta',
+      originalPrice: 135000,
+      discount: null,
+      transferPrice: 128000,
+      imageUrl: '/images/carousel-camara-violeta.webp',
+    },
+    {
+      id: 5,
+      title: '05 · Zapatillas naranjas',
+      originalPrice: 110000,
+      discount: 25,
+      transferPrice: 82500,
+      imageUrl: '/images/carousel-zapatillas-naranjas.webp',
+    },
+    {
+      id: 6,
+      title: '06 · Campera azul',
+      originalPrice: 142000,
+      discount: 12,
+      transferPrice: 121000,
+      imageUrl: '/images/carousel-campera-azul.webp',
+    },
+  ];
+
+  protected readonly trackCarouselProduct = (
+    _index: number,
+    product: CarouselProductMock,
+  ): number => product.id;
+
   protected readonly testRowProduct = {
     title: 'ENTRADA GENERAL',
     description:

src/app/features/store/pages/login-page/login-page.component.html

@@ -81,7 +81,8 @@
   variant="neutral-outline"
   hostClass="w-100 d-block"
   buttonClass="w-100 d-inline-flex align-items-center justify-content-center gap-2 py-2 fw-semibold"
-  [disabled]="true"
+  [disabled]="isSubmitting()"
+  (click)="loginWithGoogle()"
 >
   <svg
     xmlns="http://www.w3.org/2000/svg"

src/app/features/store/pages/login-page/login-page.component.ts

@@ -1,7 +1,7 @@
-import { DOCUMENT } from '@angular/common';
-import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, PLATFORM_ID, signal } from '@angular/core';
 import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
-import { Router } from '@angular/router';
+import { ActivatedRoute, Router } from '@angular/router';
 
 import { AuthService } from '../../../../core/services/auth/auth.service';
 import { ButtonComponent } from '../../../../shared/components/button/button.component';
@@ -20,8 +20,10 @@ const EMAIL_MAX_LENGTH = 255;
 export class LoginPageComponent {
   private readonly formBuilder = inject(FormBuilder);
   private readonly router = inject(Router);
+  private readonly route = inject(ActivatedRoute);
   private readonly authService = inject(AuthService);
   private readonly document = inject(DOCUMENT);
+  private readonly platformId = inject(PLATFORM_ID);
 
   private readonly submittedState = signal(false);
   private readonly serverErrorState = signal<string | null>(null);
@@ -35,6 +37,18 @@ export class LoginPageComponent {
   protected readonly serverError = this.serverErrorState.asReadonly();
   protected readonly isSubmitting = this.isSubmittingState.asReadonly();
 
+  ngOnInit(): void {
+    if (!isPlatformBrowser(this.platformId)) {
+      return;
+    }
+
+    const oauthCode = this.route.snapshot.queryParamMap.get('oauth_code');
+
+    if (oauthCode) {
+      this.completeGoogleLogin(oauthCode);
+    }
+  }
+
   goToRegister(): void {
     void this.router.navigate(['/register']);
   }
@@ -62,6 +76,16 @@ export class LoginPageComponent {
     });
   }
 
+  loginWithGoogle(): void {
+    this.serverErrorState.set(null);
+
+    try {
+      this.authService.loginWithGoogle();
+    } catch (error: unknown) {
+      this.serverErrorState.set(this.resolveErrorMessage(error));
+    }
+  }
+
   protected updateEmail(value: string | number): void {
     this.form.controls.email.setValue(String(value));
   }
@@ -107,6 +131,22 @@ export class LoginPageComponent {
     this.document.location.assign(homeUrl);
   }
 
+  private completeGoogleLogin(oauthCode: string): void {
+    this.isSubmittingState.set(true);
+    this.serverErrorState.set(null);
+
+    this.authService.completeGoogleLogin(oauthCode).subscribe({
+      next: () => {
+        this.isSubmittingState.set(false);
+        this.redirectToHome();
+      },
+      error: (error: unknown) => {
+        this.isSubmittingState.set(false);
+        this.serverErrorState.set(this.resolveErrorMessage(error));
+      }
+    });
+  }
+
   private resolveErrorMessage(error: unknown): string {
     const errorPayload =
       typeof error === 'object' && error !== null && 'error' in error

src/app/features/store/pages/register-page/register-page.component.spec.ts

@@ -50,8 +50,8 @@ describe('RegisterPageComponent', () => {
     component.form.setValue({
       nombre_apellido: 'Ada Lovelace',
       email: 'ada@example.com',
-      password: 'secret123',
-      password_confirmation: 'secret123'
+      password: 'Secret!123',
+      password_confirmation: 'Secret!123'
     });
 
     component.onSubmit();
@@ -59,8 +59,8 @@ describe('RegisterPageComponent', () => {
     expect(authService.register).toHaveBeenCalledWith({
       nombre_apellido: 'Ada Lovelace',
       email: 'ada@example.com',
-      password: 'secret123',
-      password_confirmation: 'secret123'
+      password: 'Secret!123',
+      password_confirmation: 'Secret!123'
     });
     expect(modalService.openSimple).toHaveBeenCalledWith({
       content: 'Tu cuenta fue creada correctamente',
@@ -178,8 +178,8 @@ describe('RegisterPageComponent', () => {
     component.form.setValue({
       nombre_apellido: 'Ada Lovelace',
       email: 'ada@example.com',
-      password: 'secret123',
-      password_confirmation: 'secret123'
+      password: 'Secret!123',
+      password_confirmation: 'Secret!123'
     });
     component.onSubmit();
 

src/app/features/store/pages/store-home-page/store-home-page.component.html

@@ -18,6 +18,7 @@
     <app-store-section [title]="group.title">
       <app-product-list
         [layout]="group.layout"
+        [groupLayout]="group.group_layout"
         [items]="group.items"
         [loading]="isGroupLoading(group.id)"
         (buy)="onBuyProduct($event)"

src/app/features/store/pages/store-home-page/store-home-page.component.spec.ts

@@ -56,6 +56,7 @@ function createCatalog(
       id: 7,
       title: 'Destacados',
       layout: 'column_with_image',
+      group_layout: 'paginated',
       group_order: 0,
       items: createItemsPage(items, currentPage, lastPage),
     },

src/app/features/store/pages/store-home-page/store-home-page.component.ts

@@ -53,8 +53,7 @@ export class StoreHomePageComponent implements OnInit, OnDestroy {
 
   ngOnInit(): void {
     const resolvedData = this.route.snapshot.data['catalogData'] as
-      | StoreHomeCatalogResolvedData
-      | undefined;
+      StoreHomeCatalogResolvedData | undefined;
 
     if (resolvedData) {
       this.applyResolvedData(resolvedData);
@@ -78,6 +77,7 @@ export class StoreHomePageComponent implements OnInit, OnDestroy {
 
     if (
       !group ||
+      Array.isArray(group.items) ||
       page < 1 ||
       page === group.items.meta.current_page ||
       this.isGroupLoading(groupId)
@@ -112,18 +112,15 @@ export class StoreHomePageComponent implements OnInit, OnDestroy {
   }
 
   protected onAddToCart(event: ProductListCartEvent): void {
-    this.cartService
-      .addItem(event.product.id, event.variant ?? null, event.quantity)
-      .subscribe({
-        next: (response) => {
-          this.toastService.success(response.message || 'Producto agregado al carrito');
-        },
-        error: (error: HttpErrorResponse) => {
-          const message =
-            error.error?.message || 'No se pudo agregar el producto al carrito.';
-          this.toastService.danger(message);
-        },
-      });
+    this.cartService.addItem(event.product.id, event.variant ?? null, event.quantity).subscribe({
+      next: (response) => {
+        this.toastService.success(response.message || 'Producto agregado al carrito');
+      },
+      error: (error: HttpErrorResponse) => {
+        const message = error.error?.message || 'No se pudo agregar el producto al carrito.';
+        this.toastService.danger(message);
+      },
+    });
   }
 
   private loadCatalog(): void {

src/app/shared/components/carousel/carousel.component.html

@@ -0,0 +1,74 @@
+<section class="carousel" role="region" [attr.aria-label]="ariaLabel()">
+  <div class="carousel__frame" [class.carousel__frame--with-controls]="hasMultipleItems()">
+    <div
+      #viewport
+      class="carousel__viewport"
+      [class.carousel__viewport--circular]="isCircularLayout()"
+      tabindex="0"
+      (scroll)="handleScroll()"
+      (keydown)="handleKeydown($event)"
+    >
+      @if (isCircularLayout()) {
+        <div
+          class="carousel__track"
+          [class.carousel__track--previous]="transitionDirection() === -1"
+          [class.carousel__track--next]="transitionDirection() === 1"
+          [class.carousel__track--moving]="transitionDirection() !== 0"
+          (transitionend)="finishCircularTransition($event)"
+          (transitioncancel)="finishCircularTransition($event)"
+        >
+          @for (page of circularPages(); track page.slot) {
+            <div
+              class="carousel__page"
+              [style.gap.px]="resolvedGap()"
+              [attr.aria-hidden]="page.slot === 'current' ? null : 'true'"
+              [attr.inert]="page.slot === 'current' ? null : ''"
+            >
+              @for (entry of page.items; track trackBy()(entry.index, entry.item)) {
+                <div class="carousel__item" [style.width.px]="itemWidth()">
+                  <ng-container
+                    [ngTemplateOutlet]="itemTemplate()"
+                    [ngTemplateOutletContext]="{ $implicit: entry.item, index: entry.index }"
+                  />
+                </div>
+              }
+            </div>
+          }
+        </div>
+      } @else {
+        <div class="carousel__linear-track" [style.gap.px]="resolvedGap()">
+          @for (item of items(); track trackBy()($index, item); let index = $index) {
+            <div class="carousel__item" [style.width.px]="itemWidth()">
+              <ng-container
+                [ngTemplateOutlet]="itemTemplate()"
+                [ngTemplateOutletContext]="{ $implicit: item, index }"
+              />
+            </div>
+          }
+        </div>
+      }
+    </div>
+
+    @if (hasMultipleItems()) {
+      <button
+        type="button"
+        class="carousel__control carousel__control--previous"
+        [disabled]="isPreviousDisabled()"
+        [attr.aria-label]="previousLabel()"
+        (click)="previous()"
+      >
+        <i class="fa-solid fa-chevron-left" aria-hidden="true"></i>
+      </button>
+
+      <button
+        type="button"
+        class="carousel__control carousel__control--next"
+        [disabled]="isNextDisabled()"
+        [attr.aria-label]="nextLabel()"
+        (click)="next()"
+      >
+        <i class="fa-solid fa-chevron-right" aria-hidden="true"></i>
+      </button>
+    }
+  </div>
+</section>

src/app/shared/components/carousel/carousel.component.scss

@@ -0,0 +1,138 @@
+:host {
+  display: block;
+  min-width: 0;
+}
+
+.carousel {
+  width: 100%;
+
+  &__frame {
+    position: relative;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr);
+    align-items: center;
+    width: 100%;
+    margin-inline: auto;
+
+    &--with-controls {
+      grid-template-columns: 3rem minmax(0, 1fr) 3rem;
+
+      .carousel__viewport {
+        grid-column: 2;
+      }
+    }
+  }
+
+  &__viewport {
+    grid-row: 1;
+    width: 100%;
+    overflow-x: auto;
+    overscroll-behavior-inline: contain;
+    scroll-behavior: smooth;
+    scroll-snap-type: inline mandatory;
+    scrollbar-width: none;
+
+    &::-webkit-scrollbar {
+      display: none;
+    }
+
+    &:focus-visible {
+      outline: 2px solid var(--color-primary, currentColor);
+      outline-offset: 2px;
+    }
+
+    &--circular {
+      overflow: hidden;
+      scroll-snap-type: none;
+    }
+  }
+
+  &__linear-track,
+  &__page {
+    display: flex;
+  }
+
+  &__track {
+    display: flex;
+    width: 300%;
+    transform: translateX(calc(-100% / 3));
+
+    &--moving {
+      transition: transform 300ms ease;
+    }
+
+    &--previous {
+      transform: translateX(0);
+    }
+
+    &--next {
+      transform: translateX(calc(-200% / 3));
+    }
+  }
+
+  &__page {
+    flex: 0 0 calc(100% / 3);
+    min-width: 0;
+  }
+
+  &__item {
+    flex: 0 0 auto;
+    min-width: 0;
+    scroll-snap-align: start;
+
+    > * {
+      width: 100%;
+    }
+  }
+
+  &__control {
+    grid-row: 1;
+    justify-self: center;
+    display: grid;
+    width: 2.25rem;
+    height: 2.25rem;
+    padding: 0;
+    color: var(--color-primary, #6376f3);
+    cursor: pointer;
+    background: transparent;
+    border: 0;
+    place-items: center;
+    transition:
+      color 150ms ease,
+      transform 150ms ease;
+
+    &:hover:not(:disabled) {
+      color: color-mix(in srgb, var(--color-primary, #6376f3) 78%, #000);
+      transform: scale(1.12);
+    }
+
+    &:disabled {
+      cursor: default;
+      opacity: 0;
+      pointer-events: none;
+    }
+
+    &:focus-visible {
+      outline: 2px solid var(--color-primary, currentColor);
+      outline-offset: 2px;
+    }
+
+    &--previous {
+      grid-column: 1;
+    }
+
+    &--next {
+      grid-column: 3;
+    }
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .carousel__viewport {
+    scroll-behavior: auto;
+  }
+
+  .carousel__track--moving {
+    transition-duration: 1ms;
+  }
+}

src/app/shared/components/carousel/carousel.component.spec.ts

@@ -0,0 +1,168 @@
+import { Component, signal, TemplateRef, viewChild } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CarouselComponent, CarouselItemContext } from './carousel.component';
+
+interface TestItem {
+  id: number;
+  label: string;
+}
+
+@Component({
+  imports: [CarouselComponent],
+  template: `
+    <ng-template #itemTemplate let-item let-index="index">
+      <article [attr.data-index]="index">{{ item.label }}</article>
+    </ng-template>
+
+    <app-carousel
+      [items]="items"
+      [itemTemplate]="itemTemplate"
+      [scrollStep]="120"
+      [gap]="16"
+      [circular]="circular()"
+      ariaLabel="Productos destacados"
+    />
+  `,
+})
+class TestHostComponent {
+  readonly circular = signal(false);
+
+  readonly items: TestItem[] = [
+    { id: 1, label: 'Primero' },
+    { id: 2, label: 'Segundo' },
+    { id: 3, label: 'Tercero' },
+  ];
+
+  readonly carousel = viewChild.required(CarouselComponent<TestItem>);
+  readonly itemTemplate =
+    viewChild.required<TemplateRef<CarouselItemContext<TestItem>>>('itemTemplate');
+}
+
+describe('CarouselComponent', () => {
+  let fixture: ComponentFixture<TestHostComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [TestHostComponent],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(TestHostComponent);
+    fixture.detectChanges();
+  });
+
+  it('renderiza el template provisto para cada elemento', () => {
+    const articles = fixture.nativeElement.querySelectorAll('article');
+
+    expect(articles).toHaveLength(3);
+    expect(articles[0].textContent.trim()).toBe('Primero');
+    expect(articles[1].getAttribute('data-index')).toBe('1');
+  });
+
+  it('expone una región accesible y controles con etiquetas', () => {
+    const region = fixture.nativeElement.querySelector('[role="region"]');
+    const buttons = fixture.nativeElement.querySelectorAll('button');
+
+    expect(region.getAttribute('aria-label')).toBe('Productos destacados');
+    expect(buttons[0].getAttribute('aria-label')).toBe('Mostrar elementos anteriores');
+    expect(buttons[1].getAttribute('aria-label')).toBe('Mostrar elementos siguientes');
+  });
+
+  it('desplaza el viewport en ambas direcciones', () => {
+    const viewport = fixture.nativeElement.querySelector('.carousel__viewport') as HTMLElement;
+    const scrollBy = vi.fn();
+    viewport.scrollBy = scrollBy;
+
+    fixture.componentInstance.carousel().next();
+    fixture.componentInstance.carousel().previous();
+
+    expect(scrollBy).toHaveBeenNthCalledWith(1, {
+      left: 120,
+      behavior: 'smooth',
+    });
+    expect(scrollBy).toHaveBeenNthCalledWith(2, {
+      left: -120,
+      behavior: 'smooth',
+    });
+  });
+
+  it('permite navegar con las flechas del teclado', () => {
+    const viewport = fixture.nativeElement.querySelector('.carousel__viewport') as HTMLElement;
+    const scrollBy = vi.fn();
+    viewport.scrollBy = scrollBy;
+
+    viewport.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight' }));
+    viewport.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowLeft' }));
+
+    expect(scrollBy).toHaveBeenCalledTimes(2);
+  });
+
+  it('usa todo el ancho y distribuye el espacio sobrante entre elementos completos', () => {
+    const host = fixture.nativeElement.querySelector('app-carousel') as HTMLElement;
+    const firstItem = fixture.nativeElement.querySelector('.carousel__item') as HTMLElement;
+
+    Object.defineProperty(host, 'clientWidth', {
+      configurable: true,
+      value: 650,
+    });
+    firstItem.getBoundingClientRect = vi.fn(
+      () =>
+        ({
+          width: 200,
+        }) as DOMRect,
+    );
+
+    fixture.componentInstance.carousel().ngAfterViewInit();
+    fixture.detectChanges();
+
+    const frame = fixture.nativeElement.querySelector('.carousel__frame') as HTMLElement;
+    const items = fixture.nativeElement.querySelectorAll('.carousel__item');
+
+    expect(frame.style.width).toBe('');
+    expect(items[0].style.width).toBe('269px');
+    expect(items[1].style.width).toBe('269px');
+  });
+
+  it('mantiene preparadas las páginas adyacentes y rota al terminar la transición', () => {
+    fixture.componentInstance.circular.set(true);
+    fixture.detectChanges();
+
+    const host = fixture.nativeElement.querySelector('app-carousel') as HTMLElement;
+    const firstItem = fixture.nativeElement.querySelector('.carousel__item') as HTMLElement;
+
+    Object.defineProperty(host, 'clientWidth', {
+      configurable: true,
+      value: 366,
+    });
+    firstItem.getBoundingClientRect = vi.fn(
+      () =>
+        ({
+          width: 100,
+        }) as DOMRect,
+    );
+
+    fixture.componentInstance.carousel().ngAfterViewInit();
+    fixture.detectChanges();
+
+    const pages = fixture.nativeElement.querySelectorAll('.carousel__page');
+    expect(pages).toHaveLength(3);
+    expect(pages[0].querySelectorAll('.carousel__item')).toHaveLength(2);
+    expect(pages[0].textContent).toContain('Tercero');
+    expect(pages[0].textContent).toContain('Primero');
+    expect(pages[1].textContent).toContain('Primero');
+    expect(pages[2].textContent).toContain('Tercero');
+
+    fixture.componentInstance.carousel().next();
+    fixture.detectChanges();
+
+    const track = fixture.nativeElement.querySelector('.carousel__track') as HTMLElement;
+    expect(track.classList).toContain('carousel__track--next');
+
+    track.dispatchEvent(new TransitionEvent('transitionend', { propertyName: 'transform' }));
+    fixture.detectChanges();
+
+    const recenteredPages = fixture.nativeElement.querySelectorAll('.carousel__page');
+    expect(track.classList).not.toContain('carousel__track--next');
+    expect(recenteredPages[1].textContent).toContain('Tercero');
+  });
+});

src/app/shared/components/carousel/carousel.component.ts

@@ -0,0 +1,289 @@
+import {
+  AfterViewInit,
+  ChangeDetectionStrategy,
+  Component,
+  DestroyRef,
+  ElementRef,
+  PLATFORM_ID,
+  TemplateRef,
+  computed,
+  inject,
+  input,
+  signal,
+  viewChild,
+} from '@angular/core';
+import { isPlatformBrowser, NgTemplateOutlet } from '@angular/common';
+
+export interface CarouselItemContext<T> {
+  $implicit: T;
+  index: number;
+}
+
+export type CarouselTrackBy<T> = (index: number, item: T) => unknown;
+
+interface CarouselPageItem<T> {
+  item: T;
+  index: number;
+}
+
+interface CarouselPage<T> {
+  slot: 'previous' | 'current' | 'next';
+  items: CarouselPageItem<T>[];
+}
+
+@Component({
+  selector: 'app-carousel',
+  imports: [NgTemplateOutlet],
+  templateUrl: './carousel.component.html',
+  styleUrl: './carousel.component.scss',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+})
+export class CarouselComponent<T> implements AfterViewInit {
+  private static readonly CONTROL_SLOT_WIDTH = 48;
+
+  private readonly destroyRef = inject(DestroyRef);
+  private readonly platformId = inject(PLATFORM_ID);
+  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);
+  private readonly viewport = viewChild.required<ElementRef<HTMLElement>>('viewport');
+
+  readonly items = input.required<readonly T[]>();
+  readonly itemTemplate = input.required<TemplateRef<CarouselItemContext<T>>>();
+  readonly trackBy = input<CarouselTrackBy<T>>((index) => index);
+  readonly scrollStep = input<number | null>(null);
+  readonly gap = input(0);
+  readonly circular = input(false);
+  readonly ariaLabel = input('Carrusel');
+  readonly previousLabel = input('Mostrar elementos anteriores');
+  readonly nextLabel = input('Mostrar elementos siguientes');
+
+  protected readonly canScrollPrevious = signal(false);
+  protected readonly canScrollNext = signal(false);
+  protected readonly hasOverflow = signal(false);
+  protected readonly itemWidth = signal<number | null>(null);
+  protected readonly itemsPerPage = signal(Number.MAX_SAFE_INTEGER);
+  protected readonly currentPage = signal(0);
+  protected readonly transitionDirection = signal<-1 | 0 | 1>(0);
+  protected readonly hasMultipleItems = computed(() => this.items().length > 1);
+  protected readonly resolvedGap = computed(() => Math.max(this.gap(), 0));
+  protected readonly pageCount = computed(() =>
+    Math.max(1, Math.ceil(this.items().length / this.itemsPerPage())),
+  );
+  protected readonly isCircularLayout = computed(() => this.circular() && this.pageCount() > 1);
+  protected readonly circularPages = computed<CarouselPage<T>[]>(() => {
+    const pageCount = this.pageCount();
+    const currentPage = this.normalizePage(this.currentPage(), pageCount);
+
+    return [
+      this.createPage('previous', currentPage - 1),
+      this.createPage('current', currentPage),
+      this.createPage('next', currentPage + 1),
+    ];
+  });
+  protected readonly isPreviousDisabled = computed(
+    () => !this.hasOverflow() || (!this.circular() && !this.canScrollPrevious()),
+  );
+  protected readonly isNextDisabled = computed(
+    () => !this.hasOverflow() || (!this.circular() && !this.canScrollNext()),
+  );
+
+  ngAfterViewInit(): void {
+    if (!isPlatformBrowser(this.platformId)) {
+      return;
+    }
+
+    const viewport = this.viewport().nativeElement;
+    this.refreshLayout();
+
+    const resizeObserver =
+      typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(() => this.refreshLayout());
+    resizeObserver?.observe(this.host.nativeElement);
+
+    const mutationObserver =
+      typeof MutationObserver === 'undefined'
+        ? null
+        : new MutationObserver(() => this.refreshLayout());
+    mutationObserver?.observe(viewport, { childList: true, subtree: true });
+
+    this.destroyRef.onDestroy(() => {
+      resizeObserver?.disconnect();
+      mutationObserver?.disconnect();
+    });
+  }
+
+  previous(): void {
+    if (this.circular()) {
+      this.moveCircular(-1);
+      return;
+    }
+
+    this.scroll(-1);
+  }
+
+  next(): void {
+    if (this.circular()) {
+      this.moveCircular(1);
+      return;
+    }
+
+    this.scroll(1);
+  }
+
+  scrollTo(index: number): void {
+    if (this.circular()) {
+      if (index < 0 || index >= this.items().length) {
+        return;
+      }
+
+      this.currentPage.set(Math.floor(index / this.itemsPerPage()));
+      this.transitionDirection.set(0);
+      return;
+    }
+
+    const item = this.viewport()
+      .nativeElement.querySelectorAll<HTMLElement>('.carousel__item')
+      .item(index);
+
+    item?.scrollIntoView({
+      behavior: 'smooth',
+      block: 'nearest',
+      inline: 'start',
+    });
+  }
+
+  protected handleScroll(): void {
+    if (this.circular()) {
+      return;
+    }
+
+    this.refreshNavigation();
+  }
+
+  protected finishCircularTransition(event: TransitionEvent): void {
+    if (event.target !== event.currentTarget || event.propertyName !== 'transform') {
+      return;
+    }
+
+    const direction = this.transitionDirection();
+
+    if (direction === 0) {
+      return;
+    }
+
+    this.currentPage.update((page) => this.normalizePage(page + direction, this.pageCount()));
+    this.transitionDirection.set(0);
+  }
+
+  protected handleKeydown(event: KeyboardEvent): void {
+    if (event.key === 'ArrowLeft') {
+      event.preventDefault();
+      this.previous();
+    }
+
+    if (event.key === 'ArrowRight') {
+      event.preventDefault();
+      this.next();
+    }
+  }
+
+  private scroll(direction: -1 | 1): void {
+    const viewport = this.viewport().nativeElement;
+    const configuredStep = this.scrollStep();
+    const step =
+      configuredStep !== null && configuredStep > 0
+        ? configuredStep
+        : viewport.clientWidth + this.resolvedGap();
+
+    viewport.scrollBy({
+      left: direction * step,
+      behavior: 'smooth',
+    });
+  }
+
+  private moveCircular(direction: -1 | 1): void {
+    if (!this.hasOverflow() || this.transitionDirection() !== 0) {
+      return;
+    }
+
+    this.transitionDirection.set(direction);
+  }
+
+  private refreshNavigation(): void {
+    const viewport = this.viewport().nativeElement;
+    const maxScrollLeft = Math.max(viewport.scrollWidth - viewport.clientWidth, 0);
+    const tolerance = 1;
+
+    this.hasOverflow.set(maxScrollLeft > tolerance);
+    this.canScrollPrevious.set(viewport.scrollLeft > tolerance);
+    this.canScrollNext.set(viewport.scrollLeft < maxScrollLeft - tolerance);
+  }
+
+  private refreshLayout(): void {
+    const viewport = this.viewport().nativeElement;
+    const firstItem = viewport.querySelector<HTMLElement>('.carousel__item');
+    const availableWidth = this.host.nativeElement.clientWidth;
+    const availableViewportWidth = Math.max(
+      availableWidth - (this.hasMultipleItems() ? CarouselComponent.CONTROL_SLOT_WIDTH * 2 : 0),
+      0,
+    );
+
+    if (!firstItem || availableViewportWidth <= 0) {
+      this.itemWidth.set(null);
+      this.refreshNavigation();
+      return;
+    }
+
+    const assignedWidth = firstItem.style.width;
+    firstItem.style.width = '';
+    const naturalItemWidth = firstItem.getBoundingClientRect().width;
+    firstItem.style.width = assignedWidth;
+
+    if (naturalItemWidth <= 0) {
+      this.itemWidth.set(null);
+      this.refreshNavigation();
+      return;
+    }
+
+    const gap = this.resolvedGap();
+    const fittingItems = Math.max(
+      1,
+      Math.floor((availableViewportWidth + gap) / (naturalItemWidth + gap)),
+    );
+    const visibleItems = Math.min(fittingItems, this.items().length);
+    const distributedItemWidth =
+      (availableViewportWidth - Math.max(visibleItems - 1, 0) * gap) / visibleItems;
+
+    if (this.itemsPerPage() !== fittingItems) {
+      this.itemsPerPage.set(fittingItems);
+      this.currentPage.set(0);
+      this.transitionDirection.set(0);
+    }
+
+    this.itemWidth.set(distributedItemWidth);
+    if (this.circular()) {
+      const hasOverflow = this.items().length > fittingItems;
+      this.hasOverflow.set(hasOverflow);
+      this.canScrollPrevious.set(hasOverflow);
+      this.canScrollNext.set(hasOverflow);
+    } else {
+      this.refreshNavigation();
+    }
+  }
+
+  private createPage(slot: CarouselPage<T>['slot'], page: number): CarouselPage<T> {
+    const pageCount = this.pageCount();
+    const normalizedPage = this.normalizePage(page, pageCount);
+    const start = normalizedPage * this.itemsPerPage();
+    const items: CarouselPageItem<T>[] = [];
+
+    for (let offset = 0; offset < this.itemsPerPage(); offset += 1) {
+      const index = (start + offset) % this.items().length;
+      items.push({ item: this.items()[index], index });
+    }
+
+    return { slot, items };
+  }
+
+  private normalizePage(page: number, pageCount: number): number {
+    return ((page % pageCount) + pageCount) % pageCount;
+  }
+}

src/app/shared/components/product-list/product-list.component.html

@@ -1,51 +1,79 @@
-<div
-  class="product-list"
-  [class.product-list--row]="effectiveLayout() === 'row'"
-  [class.product-list--column]="effectiveLayout() !== 'row'"
->
-  @for (item of items().data; track item.id; let index = $index) {
-    <div class="product-list__item">
-      @switch (effectiveLayout()) {
-        @case ('row') {
-          <app-product-row-card
-            [title]="item.nombre"
-            [description]="item.descripcion ?? ''"
-            [price]="price(item)"
-            [variants]="variantsFor(item)"
-            (buy)="buy.emit(item)"
-            (addToCart)="emitRowCart(item, $event)"
-          />
-        }
-        @case ('column_with_cart') {
-          <app-product-vertical-with-cart-card
-            [title]="item.nombre"
-            [description]="item.descripcion ?? ''"
-            [price]="price(item)"
-            (buy)="buy.emit(item)"
-            (addToCart)="emitColumnCart(item, $event)"
-          />
-        }
-        @default {
-          <app-product-column-with-image
-            [imageUrl]="item.image ?? null"
-            [title]="item.nombre"
-            [originalPrice]="price(item)"
-            [imagePriority]="index < 4"
-            (buy)="buy.emit(item)"
-          />
-        }
+<ng-template #productItem let-item let-index="index">
+  <div
+    class="product-list__item"
+    [class.product-list__item--carousel]="groupLayout() === 'carousel'"
+    [class.product-list__item--carousel-row]="
+      groupLayout() === 'carousel' && effectiveLayout() === 'row'
+    "
+  >
+    @switch (effectiveLayout()) {
+      @case ('row') {
+        <app-product-row-card
+          [title]="item.nombre"
+          [description]="item.descripcion ?? ''"
+          [price]="price(item)"
+          [variants]="variantsFor(item)"
+          (buy)="buy.emit(item)"
+          (addToCart)="emitRowCart(item, $event)"
+        />
       }
-    </div>
-  }
-</div>
+      @case ('column_with_cart') {
+        <app-product-vertical-with-cart-card
+          [title]="item.nombre"
+          [description]="item.descripcion ?? ''"
+          [price]="price(item)"
+          (buy)="buy.emit(item)"
+          (addToCart)="emitColumnCart(item, $event)"
+        />
+      }
+      @default {
+        <app-product-column-with-image
+          [imageUrl]="item.image ?? null"
+          [title]="item.nombre"
+          [originalPrice]="price(item)"
+          [imagePriority]="index < 4"
+          (buy)="buy.emit(item)"
+        />
+      }
+    }
+  </div>
+</ng-template>
 
-@if (items().meta.last_page > 1) {
-  <div class="product-list__paginator d-flex justify-content-center">
-    <app-paginator
-      [page]="items().meta.current_page"
-      [totalPages]="items().meta.last_page"
-      [disabled]="loading()"
-      (pageChange)="pageChange.emit($event)"
-    />
+@if (groupLayout() === 'carousel') {
+  <app-carousel
+    [items]="itemData()"
+    [itemTemplate]="productItem"
+    [trackBy]="trackProduct"
+    [gap]="24"
+    [circular]="true"
+    ariaLabel="Productos destacados"
+  />
+} @else {
+  <div
+    class="product-list"
+    [class.product-list--row]="effectiveLayout() === 'row'"
+    [class.product-list--column]="effectiveLayout() !== 'row'"
+    [class.product-list--adaptive]="groupLayout() !== 'simple_vertical'"
+    [class.product-list--simple-vertical]="groupLayout() === 'simple_vertical'"
+  >
+    @for (item of itemData(); track item.id; let index = $index) {
+      <ng-container
+        [ngTemplateOutlet]="productItem"
+        [ngTemplateOutletContext]="{ $implicit: item, index }"
+      />
+    }
   </div>
 }
+
+@if (pagination(); as paginatedItems) {
+  @if (paginatedItems.meta.last_page > 1) {
+    <div class="product-list__paginator d-flex justify-content-center">
+      <app-paginator
+        [page]="paginatedItems.meta.current_page"
+        [totalPages]="paginatedItems.meta.last_page"
+        [disabled]="loading()"
+        (pageChange)="pageChange.emit($event)"
+      />
+    </div>
+  }
+}

src/app/shared/components/product-list/product-list.component.scss

@@ -4,55 +4,39 @@
 }
 
 .product-list {
+  --product-list-item-min-width: 16rem;
+
   display: grid;
   width: 100%;
   gap: 1.5rem;
 
   &--row {
-    grid-template-columns: minmax(0, 1fr);
-
-    .product-list__item {
-      width: 100%;
-    }
+    --product-list-item-min-width: 32rem;
   }
 
-  &--column {
-    container-name: product-list;
-    container-type: inline-size;
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    align-items: stretch;
+  &--adaptive {
+    grid-template-columns: repeat(
+      auto-fit,
+      minmax(min(100%, var(--product-list-item-min-width)), 1fr)
+    );
+  }
 
-    .product-list__item {
-      flex: 0 0 100%;
-      max-width: 100%;
-    }
+  &--simple-vertical {
+    grid-template-columns: minmax(0, 1fr);
   }
 
   &__item {
+    width: 100%;
     min-width: 0;
-  }
-}
+    height: 100%;
 
-@container product-list (min-width: 544px) {
-  .product-list--column .product-list__item {
-    flex-basis: calc((100% - 1.5rem) / 2);
-    max-width: calc((100% - 1.5rem) / 2);
-  }
-}
+    &--carousel {
+      min-width: clamp(15rem, 30vw, 18rem);
+    }
 
-@container product-list (min-width: 828px) {
-  .product-list--column .product-list__item {
-    flex-basis: calc((100% - 3rem) / 3);
-    max-width: calc((100% - 3rem) / 3);
-  }
-}
-
-@container product-list (min-width: 1112px) {
-  .product-list--column .product-list__item {
-    flex-basis: calc((100% - 4.5rem) / 4);
-    max-width: calc((100% - 4.5rem) / 4);
+    &--carousel-row {
+      min-width: clamp(18rem, 70vw, 32rem);
+    }
   }
 }
 

src/app/shared/components/product-list/product-list.component.spec.ts

@@ -3,6 +3,10 @@ import { BrowserTestingModule, platformBrowserTesting } from '@angular/platform-
 import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 
 import { ApiPaginatedResponse } from '../../../core/services/api-paginated-response.interface';
+import {
+  CatalogFeaturedItems,
+  CatalogGroupLayout,
+} from '../../../core/services/catalog/catalog.interface';
 import { ProductListComponent, ProductListItem, ProductListLayout } from './product-list.component';
 
 describe('ProductListComponent', () => {
@@ -38,11 +42,16 @@ describe('ProductListComponent', () => {
     TestBed.resetTestingModule();
   });
 
-  async function render(layout: ProductListLayout) {
+  async function render(
+    layout: ProductListLayout,
+    productItems: CatalogFeaturedItems = paginatedItems(),
+    groupLayout: CatalogGroupLayout = 'paginated',
+  ) {
     await TestBed.configureTestingModule({ imports: [ProductListComponent] }).compileComponents();
     const fixture = TestBed.createComponent(ProductListComponent);
     fixture.componentRef.setInput('layout', layout);
-    fixture.componentRef.setInput('items', paginatedItems());
+    fixture.componentRef.setInput('groupLayout', groupLayout);
+    fixture.componentRef.setInput('items', productItems);
     fixture.detectChanges();
 
     return fixture;
@@ -70,11 +79,12 @@ describe('ProductListComponent', () => {
     };
   }
 
-  it('renders every row product at full available width', async () => {
+  it('renders row products in the adaptive grid', async () => {
     const fixture = await render('row');
     const element = fixture.nativeElement as HTMLElement;
 
     expect(element.querySelector('.product-list--row')).not.toBeNull();
+    expect(element.querySelector('.product-list--adaptive')).not.toBeNull();
     expect(element.querySelectorAll('app-product-row-card')).toHaveLength(2);
     expect(element.querySelector('app-product-column-with-image')).toBeNull();
   });
@@ -128,4 +138,33 @@ describe('ProductListComponent', () => {
 
     expect(pageChangeSpy).toHaveBeenCalledWith(2);
   });
+
+  it('renders plain items without pagination', async () => {
+    const fixture = await render('row', items, 'simple');
+    const element = fixture.nativeElement as HTMLElement;
+
+    expect(element.querySelectorAll('app-product-row-card')).toHaveLength(2);
+    expect(element.querySelector('.product-list--adaptive')).not.toBeNull();
+    expect(element.querySelector('app-paginator')).toBeNull();
+  });
+
+  it('keeps simple vertical groups to one full-width item per row', async () => {
+    const fixture = await render('column_with_image', items, 'simple_vertical');
+    const element = fixture.nativeElement as HTMLElement;
+
+    expect(element.querySelector('.product-list--simple-vertical')).not.toBeNull();
+    expect(element.querySelector('.product-list--adaptive')).toBeNull();
+    expect(element.querySelectorAll('app-product-column-with-image')).toHaveLength(2);
+  });
+
+  it('renders carousel groups with the reusable carousel', async () => {
+    const fixture = await render('column_with_image', items, 'carousel');
+    const element = fixture.nativeElement as HTMLElement;
+
+    expect(element.querySelector('app-carousel')).not.toBeNull();
+    expect(element.querySelector('.product-list')).toBeNull();
+    expect(element.querySelectorAll('app-product-column-with-image')).toHaveLength(2);
+    expect(element.querySelectorAll('.product-list__item--carousel')).toHaveLength(2);
+    expect(element.querySelector('app-paginator')).toBeNull();
+  });
 });

src/app/shared/components/product-list/product-list.component.ts

@@ -9,13 +9,16 @@ import {
   output,
   signal,
 } from '@angular/core';
+import { NgTemplateOutlet } from '@angular/common';
 
-import { ApiPaginatedResponse } from '../../../core/services/api-paginated-response.interface';
 import {
   CatalogFeaturedItem,
+  CatalogFeaturedItems,
   CatalogFeaturedItemVariant,
+  CatalogGroupLayout,
   CatalogProductLayout,
 } from '../../../core/services/catalog/catalog.interface';
+import { CarouselComponent } from '../carousel/carousel.component';
 import { PaginatorComponent } from '../paginator/paginator.component';
 import { ProductColumnWithImageComponent } from '../product-column-with-image/product-column-with-image.component';
 import {
@@ -37,6 +40,8 @@ export interface ProductListCartEvent {
 @Component({
   selector: 'app-product-list',
   imports: [
+    CarouselComponent,
+    NgTemplateOutlet,
     ProductColumnWithImageComponent,
     PaginatorComponent,
     ProductRowCardComponent,
@@ -51,7 +56,8 @@ export class ProductListComponent {
   private readonly mobile = signal(false);
 
   readonly layout = input.required<ProductListLayout>();
-  readonly items = input.required<ApiPaginatedResponse<ProductListItem[]>>();
+  readonly groupLayout = input.required<CatalogGroupLayout>();
+  readonly items = input.required<CatalogFeaturedItems>();
   readonly loading = input(false);
 
   readonly buy = output<ProductListItem>();
@@ -61,6 +67,17 @@ export class ProductListComponent {
   protected readonly effectiveLayout = computed<ProductListLayout>(() =>
     this.mobile() && this.layout() === 'row' ? 'column_with_cart' : this.layout(),
   );
+  protected readonly itemData = computed(() => {
+    const items = this.items();
+
+    return Array.isArray(items) ? items : items.data;
+  });
+  protected readonly pagination = computed(() => {
+    const items = this.items();
+
+    return Array.isArray(items) ? null : items;
+  });
+  protected readonly trackProduct = (_index: number, item: ProductListItem): number => item.id;
 
   constructor() {
     afterNextRender(() => {