@decocms/apps-vtex 8.1.0-next.0 → 8.1.0-next.1

package/src/utils/__tests__/transform.test.ts

@@ -1,1111 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Offer, Product } from "@decocms/apps-commerce/types";
-import {
-	aggregateOffers,
-	bestOfferFirst,
-	categoryTreeToNavbar,
-	filtersFromURL,
-	filtersToSearchParams,
-	forceHttpsOnAssets,
-	inStock,
-	legacyFacetsFromURL,
-	legacyFacetsNormalize,
-	mergeFacets,
-	normalizeFacet,
-	parsePageType,
-	pickSku,
-	SCHEMA_IN_STOCK,
-	SCHEMA_OUT_OF_STOCK,
-	sortProducts,
-	toAdditionalPropertyCategory,
-	toAdditionalPropertyCluster,
-	toAdditionalPropertyReferenceId,
-	toAdditionalPropertySpecification,
-	toBrand,
-	toPostalAddress,
-	toProduct,
-	toProductShelf,
-	toProductVariant,
-} from "../transform";
-
-const makeOffer = (price: number, availability: string): Offer => ({
-	"@type": "Offer",
-	price,
-	availability: availability as Offer["availability"],
-	priceSpecification: [],
-	inventoryLevel: { value: 1 },
-});
-
-describe("inStock", () => {
-	it("returns true when in stock", () => {
-		expect(inStock(makeOffer(10, SCHEMA_IN_STOCK))).toBe(true);
-	});
-
-	it("returns false when out of stock", () => {
-		expect(inStock(makeOffer(10, SCHEMA_OUT_OF_STOCK))).toBe(false);
-	});
-});
-
-describe("bestOfferFirst", () => {
-	it("sorts in-stock before out-of-stock", () => {
-		const inStockOffer = makeOffer(100, SCHEMA_IN_STOCK);
-		const outOfStockOffer = makeOffer(10, SCHEMA_OUT_OF_STOCK);
-		expect(bestOfferFirst(inStockOffer, outOfStockOffer)).toBe(-1);
-		expect(bestOfferFirst(outOfStockOffer, inStockOffer)).toBe(1);
-	});
-
-	it("sorts by price when both in stock", () => {
-		const cheap = makeOffer(10, SCHEMA_IN_STOCK);
-		const expensive = makeOffer(100, SCHEMA_IN_STOCK);
-		expect(bestOfferFirst(cheap, expensive)).toBeLessThan(0);
-		expect(bestOfferFirst(expensive, cheap)).toBeGreaterThan(0);
-	});
-
-	it("returns 0 for equal offers", () => {
-		const a = makeOffer(50, SCHEMA_IN_STOCK);
-		const b = makeOffer(50, SCHEMA_IN_STOCK);
-		expect(bestOfferFirst(a, b)).toBe(0);
-	});
-});
-
-describe("aggregateOffers", () => {
-	it("returns undefined for empty array", () => {
-		expect(aggregateOffers([])).toBeUndefined();
-	});
-
-	it("aggregates single offer", () => {
-		const offer = makeOffer(100, SCHEMA_IN_STOCK);
-		const result = aggregateOffers([offer], "BRL");
-		expect(result).toEqual({
-			"@type": "AggregateOffer",
-			priceCurrency: "BRL",
-			highPrice: 100,
-			lowPrice: 100,
-			offerCount: 1,
-			offers: [offer],
-		});
-	});
-
-	it("finds low and high prices across multiple offers", () => {
-		const offers = [
-			makeOffer(50, SCHEMA_IN_STOCK),
-			makeOffer(100, SCHEMA_IN_STOCK),
-			makeOffer(25, SCHEMA_IN_STOCK),
-		];
-		const result = aggregateOffers(offers, "BRL");
-		expect(result?.lowPrice).toBe(25);
-		expect(result?.highPrice).toBe(100);
-		expect(result?.offerCount).toBe(3);
-	});
-
-	it("ignores out-of-stock offers for high price", () => {
-		const offers = [makeOffer(25, SCHEMA_IN_STOCK), makeOffer(200, SCHEMA_OUT_OF_STOCK)];
-		const result = aggregateOffers(offers, "BRL");
-		expect(result?.highPrice).toBe(25);
-	});
-});
-
-describe("pickSku", () => {
-	const makeProduct = (
-		items: Array<{
-			itemId: string;
-			sellers: Array<{ commertialOffer: { AvailableQuantity: number } }>;
-		}>,
-	) => ({ items, origin: "intelligent-search" }) as any;
-
-	it("returns specified SKU", () => {
-		const product = makeProduct([
-			{ itemId: "1", sellers: [{ commertialOffer: { AvailableQuantity: 0 } }] },
-			{ itemId: "2", sellers: [{ commertialOffer: { AvailableQuantity: 5 } }] },
-		]);
-		expect(pickSku(product, "2").itemId).toBe("2");
-	});
-
-	it("returns first available SKU when no ID specified", () => {
-		const product = makeProduct([
-			{ itemId: "1", sellers: [{ commertialOffer: { AvailableQuantity: 0 } }] },
-			{ itemId: "2", sellers: [{ commertialOffer: { AvailableQuantity: 5 } }] },
-		]);
-		expect(pickSku(product).itemId).toBe("2");
-	});
-
-	it("falls back to first SKU when none available", () => {
-		const product = makeProduct([
-			{ itemId: "1", sellers: [{ commertialOffer: { AvailableQuantity: 0 } }] },
-			{ itemId: "2", sellers: [{ commertialOffer: { AvailableQuantity: 0 } }] },
-		]);
-		expect(pickSku(product).itemId).toBe("1");
-	});
-
-	it("falls back to first SKU when specified ID not found", () => {
-		const product = makeProduct([
-			{ itemId: "1", sellers: [{ commertialOffer: { AvailableQuantity: 5 } }] },
-		]);
-		expect(pickSku(product, "999").itemId).toBe("1");
-	});
-});
-
-describe("toAdditionalPropertyCategory", () => {
-	it("creates category property value", () => {
-		const result = toAdditionalPropertyCategory({ propertyID: "123", value: "Shoes" });
-		expect(result).toEqual({
-			"@type": "PropertyValue",
-			name: "category",
-			propertyID: "123",
-			value: "Shoes",
-		});
-	});
-});
-
-describe("toAdditionalPropertyCluster", () => {
-	it("creates cluster property value", () => {
-		const result = toAdditionalPropertyCluster({ propertyID: "456", value: "Sale" });
-		expect(result).toEqual({
-			"@type": "PropertyValue",
-			name: "cluster",
-			propertyID: "456",
-			value: "Sale",
-			description: undefined,
-		});
-	});
-
-	it("marks as highlight when in set", () => {
-		const highlights = new Set(["456"]);
-		const result = toAdditionalPropertyCluster({ propertyID: "456", value: "Sale" }, highlights);
-		expect(result.description).toBe("highlight");
-	});
-
-	it("does not mark as highlight when not in set", () => {
-		const highlights = new Set(["789"]);
-		const result = toAdditionalPropertyCluster({ propertyID: "456", value: "Sale" }, highlights);
-		expect(result.description).toBeUndefined();
-	});
-});
-
-describe("toAdditionalPropertyReferenceId", () => {
-	it("creates reference ID property value", () => {
-		const result = toAdditionalPropertyReferenceId({ name: "RefId", value: "ABC123" });
-		expect(result).toEqual({
-			"@type": "PropertyValue",
-			name: "RefId",
-			value: "ABC123",
-			valueReference: "ReferenceID",
-		});
-	});
-});
-
-describe("toAdditionalPropertySpecification", () => {
-	it("creates specification property value", () => {
-		const result = toAdditionalPropertySpecification({ name: "Color", value: "Red" });
-		expect(result).toEqual({
-			"@type": "PropertyValue",
-			name: "Color",
-			value: "Red",
-			propertyID: undefined,
-			valueReference: "SPECIFICATION",
-		});
-	});
-
-	it("includes propertyID when provided", () => {
-		const result = toAdditionalPropertySpecification({
-			name: "Color",
-			value: "Red",
-			propertyID: "group1",
-		});
-		expect(result.propertyID).toBe("group1");
-	});
-});
-
-describe("filtersToSearchParams", () => {
-	it("converts facets to search params", () => {
-		const facets = [
-			{ key: "category", value: "shoes" },
-			{ key: "brand", value: "nike" },
-		];
-		const params = filtersToSearchParams(facets);
-		expect(params.get("filter.category")).toBe("shoes");
-		expect(params.get("filter.brand")).toBe("nike");
-	});
-
-	it("preserves existing params", () => {
-		const existing = new URLSearchParams("page=1");
-		const params = filtersToSearchParams([{ key: "brand", value: "nike" }], existing);
-		expect(params.get("page")).toBe("1");
-		expect(params.get("filter.brand")).toBe("nike");
-	});
-});
-
-describe("legacyFacetsNormalize", () => {
-	it("normalizes legacy price format", () => {
-		const result = legacyFacetsNormalize("priceFrom", "de-34,90-a-56,90");
-		expect(result).toEqual({ key: "price", value: "34.90:56.90" });
-	});
-
-	it("maps legacy key names", () => {
-		const result = legacyFacetsNormalize("productClusterSearchableIds", "123");
-		expect(result).toEqual({ key: "productClusterIds", value: "123" });
-	});
-
-	it("passes through unknown keys", () => {
-		const result = legacyFacetsNormalize("brand", "nike");
-		expect(result).toEqual({ key: "brand", value: "nike" });
-	});
-});
-
-describe("legacyFacetsFromURL", () => {
-	it("extracts facets from URL with map param", () => {
-		const url = new URL("https://example.com/shoes/nike?map=c,brand");
-		const result = legacyFacetsFromURL(url);
-		expect(result).toEqual([
-			{ key: "c", value: "shoes" },
-			{ key: "brand", value: "nike" },
-		]);
-	});
-
-	it("returns empty array when no map param", () => {
-		const url = new URL("https://example.com/shoes");
-		const result = legacyFacetsFromURL(url);
-		expect(result).toEqual([]);
-	});
-
-	it("handles mismatched lengths", () => {
-		const url = new URL("https://example.com/shoes?map=c,brand,extra");
-		const result = legacyFacetsFromURL(url);
-		expect(result).toHaveLength(1);
-	});
-});
-
-describe("filtersFromURL", () => {
-	it("extracts both legacy and filter params", () => {
-		const url = new URL("https://example.com/shoes?map=c&filter.brand=nike");
-		const result = filtersFromURL(url);
-		expect(result).toEqual([
-			{ key: "c", value: "shoes" },
-			{ key: "brand", value: "nike" },
-		]);
-	});
-
-	it("extracts only filter params when no map", () => {
-		const url = new URL("https://example.com/?filter.brand=nike&filter.category=shoes");
-		const result = filtersFromURL(url);
-		expect(result).toEqual([
-			{ key: "brand", value: "nike" },
-			{ key: "category", value: "shoes" },
-		]);
-	});
-});
-
-describe("mergeFacets", () => {
-	it("merges two facet arrays", () => {
-		const f1 = [{ key: "brand", value: "nike" }];
-		const f2 = [{ key: "category", value: "shoes" }];
-		const result = mergeFacets(f1, f2);
-		expect(result).toHaveLength(2);
-	});
-
-	it("deduplicates facets", () => {
-		const f1 = [{ key: "brand", value: "nike" }];
-		const f2 = [{ key: "brand", value: "nike" }];
-		const result = mergeFacets(f1, f2);
-		expect(result).toHaveLength(1);
-	});
-
-	it("keeps both when same key different value", () => {
-		const f1 = [{ key: "brand", value: "nike" }];
-		const f2 = [{ key: "brand", value: "adidas" }];
-		const result = mergeFacets(f1, f2);
-		expect(result).toHaveLength(2);
-	});
-});
-
-describe("categoryTreeToNavbar", () => {
-	it("transforms tree to navbar elements", () => {
-		const tree = [
-			{
-				id: 1,
-				name: "Shoes",
-				hasChildren: true,
-				url: "https://example.com/shoes",
-				children: [
-					{
-						id: 2,
-						name: "Running",
-						hasChildren: false,
-						url: "https://example.com/shoes/running",
-						children: [],
-					},
-				],
-			},
-		];
-		const result = categoryTreeToNavbar(tree);
-		expect(result).toEqual([
-			{
-				"@type": "SiteNavigationElement",
-				url: "/shoes",
-				name: "Shoes",
-				children: [
-					{
-						"@type": "SiteNavigationElement",
-						url: "/shoes/running",
-						name: "Running",
-						children: [],
-					},
-				],
-			},
-		]);
-	});
-
-	it("returns empty array for empty tree", () => {
-		expect(categoryTreeToNavbar([])).toEqual([]);
-	});
-});
-
-describe("toBrand", () => {
-	it("transforms VTEX brand", () => {
-		const brand = {
-			id: 1,
-			name: "Nike",
-			imageUrl: "/brands/nike.png",
-			metaTagDescription: "Nike brand",
-		};
-		const result = toBrand(brand as any, "https://example.com");
-		expect(result).toEqual({
-			"@type": "Brand",
-			"@id": "1",
-			name: "Nike",
-			logo: "https://example.com/brands/nike.png",
-			description: "Nike brand",
-		});
-	});
-
-	it("keeps absolute URLs as-is", () => {
-		const brand = {
-			id: 1,
-			name: "Nike",
-			imageUrl: "https://cdn.example.com/nike.png",
-			metaTagDescription: "",
-		};
-		const result = toBrand(brand as any, "https://example.com");
-		expect(result.logo).toBe("https://cdn.example.com/nike.png");
-	});
-});
-
-describe("normalizeFacet", () => {
-	it("sets Map to priceFrom and Value to Slug", () => {
-		const facet = { Map: "c", Value: "shoes", Slug: "de-10-a-50", Name: "Price", Quantity: 5 };
-		const result = normalizeFacet(facet as any);
-		expect(result.Map).toBe("priceFrom");
-		expect(result.Value).toBe("de-10-a-50");
-	});
-});
-
-describe("sortProducts", () => {
-	it("sorts products by specified order", () => {
-		const products = [
-			{ "@type": "Product", sku: "3" },
-			{ "@type": "Product", sku: "1" },
-			{ "@type": "Product", sku: "2" },
-		] as unknown as Product[];
-		const result = sortProducts(products, ["1", "2", "3"], "sku");
-		expect(result.map((p) => p.sku)).toEqual(["1", "2", "3"]);
-	});
-
-	it("returns undefined for missing IDs", () => {
-		const products = [{ "@type": "Product", sku: "1" }] as unknown as Product[];
-		const result = sortProducts(products, ["1", "999"], "sku");
-		expect(result[0].sku).toBe("1");
-		expect(result[1]).toBeUndefined();
-	});
-});
-
-describe("parsePageType", () => {
-	it("maps FullText to Search", () => {
-		expect(parsePageType({ pageType: "FullText" } as any)).toBe("Search");
-	});
-
-	it("maps NotFound to Unknown", () => {
-		expect(parsePageType({ pageType: "NotFound" } as any)).toBe("Unknown");
-	});
-
-	it("passes through other types", () => {
-		expect(parsePageType({ pageType: "Department" } as any)).toBe("Department");
-		expect(parsePageType({ pageType: "Brand" } as any)).toBe("Brand");
-	});
-});
-
-describe("forceHttpsOnAssets", () => {
-	it("converts http to https on item images", () => {
-		const orderForm = {
-			items: [
-				{ imageUrl: "http://example.com/img.jpg" },
-				{ imageUrl: "https://example.com/img2.jpg" },
-			],
-		};
-		const result = forceHttpsOnAssets(orderForm as any);
-		expect(result.items[0].imageUrl).toBe("https://example.com/img.jpg");
-		expect(result.items[1].imageUrl).toBe("https://example.com/img2.jpg");
-	});
-
-	it("handles items without imageUrl", () => {
-		const orderForm = { items: [{ imageUrl: undefined }] };
-		const result = forceHttpsOnAssets(orderForm as any);
-		expect(result.items[0].imageUrl).toBeUndefined();
-	});
-});
-
-describe("toPostalAddress", () => {
-	it("transforms VTEX address to PostalAddress", () => {
-		const address = {
-			addressId: "addr1",
-			country: "BRA",
-			city: "São Paulo",
-			state: "SP",
-			neighborhood: "Pinheiros",
-			postalCode: "05422-000",
-			street: "Rua dos Pinheiros",
-			number: "123",
-			addressName: "Home",
-			receiverName: "John Doe",
-			complement: "Apt 1",
-			reference: "Near the park",
-			geoCoordinates: [-23.5668, -46.6901],
-		};
-		const result = toPostalAddress(address as any);
-		expect(result["@type"]).toBe("PostalAddress");
-		expect(result["@id"]).toBe("addr1");
-		expect(result.addressCountry).toBe("BRA");
-		expect(result.addressLocality).toBe("São Paulo");
-		expect(result.addressRegion).toBe("SP");
-		expect(result.postalCode).toBe("05422-000");
-		expect(result.streetAddress).toBe("Rua dos Pinheiros");
-		expect(result.identifier).toBe("123");
-		expect(result.name).toBe("Home");
-		expect(result.alternateName).toBe("John Doe");
-	});
-
-	it("returns undefined for empty optional fields", () => {
-		const address = {
-			addressId: "addr1",
-			country: "BRA",
-			city: "SP",
-			state: "SP",
-			postalCode: "05422-000",
-			street: "Rua X",
-		};
-		const result = toPostalAddress(address as any);
-		expect(result.areaServed).toBeUndefined();
-		expect(result.identifier).toBeUndefined();
-		expect(result.name).toBeUndefined();
-	});
-});
-
-describe("toProductVariant", () => {
-	const makeISProduct = (overrides: Record<string, unknown> = {}) =>
-		({
-			origin: "intelligent-search",
-			productId: "PROD1",
-			productName: "Test Product",
-			brand: "TestBrand",
-			brandId: 1,
-			brandImageUrl: null,
-			productReference: "REF1",
-			description: "Full description HTML",
-			releaseDate: "2024-01-01",
-			linkText: "test-product",
-			categories: ["/Electronics/TVs/"],
-			categoriesIds: ["/1/2/"],
-			categoryId: "2",
-			productClusters: { "100": "Sale" },
-			clusterHighlights: {},
-			items: [],
-			...overrides,
-		}) as any;
-
-	const makeISSku = (overrides: Record<string, unknown> = {}) =>
-		({
-			itemId: "SKU1",
-			name: "Test SKU",
-			ean: "1234567890123",
-			referenceId: [{ Key: "RefId", Value: "REF-SKU1" }],
-			images: [
-				{ imageUrl: "https://img.com/1.jpg", imageText: "Front", imageLabel: "front" },
-				{ imageUrl: "https://img.com/2.jpg", imageText: "Back", imageLabel: "back" },
-				{ imageUrl: "https://img.com/3.jpg", imageText: "Side", imageLabel: "side" },
-			],
-			videos: ["https://video.com/1.mp4"],
-			sellers: [
-				{
-					sellerId: "1",
-					sellerName: "Seller One",
-					commertialOffer: {
-						AvailableQuantity: 10,
-						Price: 99.9,
-						ListPrice: 129.9,
-						spotPrice: 89.9,
-						PriceValidUntil: "2025-12-31",
-						Installments: [
-							{
-								Value: 33.3,
-								NumberOfInstallments: 3,
-								Name: "Visa",
-								InterestRate: 0,
-								TotalValuePlusInterestRate: 99.9,
-								PaymentSystemName: "Visa",
-							},
-						],
-						GiftSkuIds: [],
-						teasers: [],
-					},
-				},
-			],
-			variations: [
-				{ name: "Cor", values: ["Preto"] },
-				{ name: "Voltagem", values: ["220V"] },
-				{ name: "Tamanho", values: ["G"] },
-			],
-			kitItems: [],
-			complementName: "Complement",
-			estimatedDateArrival: null,
-			modalType: null,
-			...overrides,
-		}) as any;
-
-	const baseOptions = {
-		baseUrl: "https://example.com",
-		priceCurrency: "BRL",
-	};
-
-	it("returns minimal product shape", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, baseOptions);
-
-		expect(result["@type"]).toBe("Product");
-		expect(result.productID).toBe("SKU1");
-		expect(result.sku).toBe("SKU1");
-		expect(result.name).toBe("Test SKU");
-		expect(result.url).toContain("/test-product/p");
-		expect(result.inProductGroupWithID).toBe("PROD1");
-	});
-
-	it("drops description, video, brand, gtin, releaseDate, isVariantOf", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, baseOptions);
-
-		expect(result.video).toBeUndefined();
-		expect(result.description).toBeUndefined();
-		expect(result.brand).toBeUndefined();
-		expect(result.gtin).toBeUndefined();
-		expect(result.releaseDate).toBeUndefined();
-		expect(result.alternateName).toBeUndefined();
-		expect(result.isVariantOf).toBeUndefined();
-		expect(result.isAccessoryOrSparePartFor).toBeUndefined();
-		expect(result.category).toBeUndefined();
-	});
-
-	it("includes image[0] by default — selectors render thumbnails from it", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, baseOptions);
-
-		expect(result.image).toHaveLength(1);
-		expect(result.image?.[0]).toMatchObject({
-			"@type": "ImageObject",
-			url: "https://img.com/1.jpg",
-			encodingFormat: "image",
-		});
-	});
-
-	it("includes real inventoryLevel by default — selectors gate stock state on it", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, baseOptions);
-
-		const offer = result.offers!.offers[0];
-		expect(offer.inventoryLevel?.value).toBe(10);
-	});
-
-	it("drops image when variantIncludeImage: false", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, {
-			...baseOptions,
-			variantIncludeImage: false,
-		});
-
-		expect(result.image).toBeUndefined();
-	});
-
-	it("zeros inventoryLevel when variantIncludeInventory: false (legacy lean behavior)", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, {
-			...baseOptions,
-			variantIncludeInventory: false,
-		});
-
-		const offer = result.offers!.offers[0];
-		expect(offer.inventoryLevel?.value).toBe(0);
-	});
-
-	it("filters spec additionalProperty to variant-differentiating names only", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, baseOptions);
-
-		const specNames = (result.additionalProperty ?? [])
-			.filter((p) => p.valueReference !== "ReferenceID")
-			.map((p) => p.name);
-		// Should only contain Cor, Voltagem, Tamanho (from VARIANT_PROPERTY_NAMES)
-		for (const name of specNames) {
-			expect(["Cor", "Voltagem", "Tamanho"]).toContain(name);
-		}
-		expect(specNames.length).toBeGreaterThan(0);
-	});
-
-	it("respects custom variantPropertyNames", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, {
-			...baseOptions,
-			variantPropertyNames: new Set(["Cor"]),
-		});
-
-		const specNames = (result.additionalProperty ?? [])
-			.filter((p) => p.valueReference !== "ReferenceID")
-			.map((p) => p.name);
-		expect(specNames).toEqual(["Cor"]);
-	});
-
-	// Analytics reads the SKU RefId off additionalProperty for GA4 dimension2
-	// (view_item_list / select_item) and its productImpression / productClick
-	// equivalents. It lives in `referenceId`, not `variations`, so the
-	// variantProps filter used to drop it and blank the dimension.
-	it("keeps the SKU reference ids (RefId) alongside the variant specs", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = { ...makeISSku(), referenceId: [{ Key: "RefId", Value: "010276949803" }] };
-		const result = toProductVariant(product, sku, baseOptions);
-
-		const refId = result.additionalProperty?.find((p) => p.name === "RefId");
-		expect(refId?.value).toBe("010276949803");
-		expect(refId?.valueReference).toBe("ReferenceID");
-	});
-
-	it("omits RefId when the SKU carries no referenceId", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = { ...makeISSku(), referenceId: undefined };
-		const result = toProductVariant(product, sku, baseOptions);
-
-		expect(result.additionalProperty?.some((p) => p.name === "RefId")).toBe(false);
-	});
-
-	it("produces lean offers with availability but no priceSpecification details", () => {
-		const product = makeISProduct({ items: [makeISSku()] });
-		const sku = makeISSku();
-		const result = toProductVariant(product, sku, baseOptions);
-
-		expect(result.offers).toBeDefined();
-		expect(result.offers?.offers).toHaveLength(1);
-
-		const offer = result.offers!.offers[0];
-		expect(offer.availability).toBe("https://schema.org/InStock");
-		expect(offer.seller).toBe("1");
-		expect(offer.priceSpecification).toEqual([]);
-	});
-
-	it("handles SKU with no sellers", () => {
-		const product = makeISProduct({ items: [makeISSku({ sellers: [] })] });
-		const sku = makeISSku({ sellers: [] });
-		const result = toProductVariant(product, sku, baseOptions);
-
-		// Should still return a valid product, offers may be undefined (no sellers)
-		expect(result["@type"]).toBe("Product");
-		expect(result.productID).toBe("SKU1");
-	});
-});
-
-describe("toProductShelf", () => {
-	const makeSku = (overrides: Record<string, unknown> = {}) =>
-		({
-			itemId: "SKU1",
-			name: "Test SKU",
-			referenceId: [{ Key: "RefId", Value: "REF-SKU1" }],
-			images: [{ imageUrl: "https://img.com/1.jpg", imageText: "Front", imageLabel: "front" }],
-			sellers: [
-				{
-					sellerId: "1",
-					sellerName: "Seller One",
-					commertialOffer: {
-						AvailableQuantity: 10,
-						Price: 99.9,
-						ListPrice: 129.9,
-						spotPrice: 89.9,
-						PriceValidUntil: "2025-12-31",
-						Installments: [],
-						GiftSkuIds: [],
-						teasers: [],
-					},
-				},
-			],
-			variations: [{ name: "Cor", values: ["Preto"] }],
-			...overrides,
-		}) as any;
-
-	// Campanha is a PRODUCT specification (in specificationGroups), NOT a sku.variation.
-	// It is the marker one storefront uses to tag launches ("Lançamentos").
-	const makeProduct = (overrides: Record<string, unknown> = {}) =>
-		({
-			origin: "intelligent-search",
-			productId: "PROD1",
-			productName: "Test Product",
-			brand: "TestBrand",
-			linkText: "test-product",
-			categories: ["/Electronics/"],
-			categoriesIds: ["/1/"],
-			categoryId: "1",
-			productClusters: [{ id: "100", name: "Sale" }],
-			clusterHighlights: [],
-			specificationGroups: [
-				{ name: "Campanha", specifications: [{ name: "Campanha", values: ["Lançamentos"] }] },
-			],
-			items: [makeSku()],
-			...overrides,
-		}) as any;
-
-	const options = { baseUrl: "https://example.com", priceCurrency: "BRL" };
-
-	it("surfaces the Campanha launch spec in isVariantOf.additionalProperty (ReleaseFlag reads it)", () => {
-		const result = toProductShelf(makeProduct(), makeSku(), 0, options);
-		const groupProps = result.isVariantOf?.additionalProperty ?? [];
-		expect(groupProps).toEqual(
-			expect.arrayContaining([
-				expect.objectContaining({ name: "Campanha", value: "Lançamentos" }),
-			]),
-		);
-	});
-
-	it("leaves isVariantOf.additionalProperty empty when there is no shelf-safe group spec", () => {
-		const result = toProductShelf(
-			makeProduct({ specificationGroups: [] }),
-			makeSku(),
-			0,
-			options,
-		);
-		expect(result.isVariantOf?.additionalProperty).toEqual([]);
-	});
-
-	// Analytics reads the product reference off isVariantOf.model for GA4
-	// dimension1 (view_item_list / select_item) and its productImpression /
-	// productClick equivalents. toProductShelf used to drop it, blanking the
-	// dimension on every shelf, PLP and search result.
-	it("carries productReference on isVariantOf.model (analytics dimension1)", () => {
-		const result = toProductShelf(
-			makeProduct({ productReference: "0102769498" }),
-			makeSku(),
-			0,
-			options,
-		);
-		expect(result.isVariantOf?.model).toBe("0102769498");
-	});
-
-	it("keeps the SKU RefId reachable on the complete-variants shelf (dimension2)", () => {
-		const result = toProductShelf(makeProduct(), makeSku(), 0, {
-			...options,
-			shelfCompleteVariants: true,
-		});
-		const variantProps = result.isVariantOf?.hasVariant?.[0]?.additionalProperty ?? [];
-		expect(variantProps).toEqual(
-			expect.arrayContaining([expect.objectContaining({ name: "RefId", value: "REF-SKU1" })]),
-		);
-	});
-
-	// A real catalog registers the packshot and the colour thumbnail LAST:
-	// measured on a live store, `secondary` sits at index 6 and `color-thumbnail`
-	// at index 7 of 8. A card that selects either BY NAME gets nothing from a
-	// positional cap and silently falls back to the first photo (the model
-	// wearing the piece).
-	const labelledImages = [
-		...Array.from({ length: 6 }, (_, i) => ({
-			imageUrl: `https://img.com/photo-${i}.jpg`,
-			imageText: `Photo ${i}`,
-			imageLabel: `product-photo-${i}`,
-		})),
-		{ imageUrl: "https://img.com/still.jpg", imageText: "Still", imageLabel: "secondary" },
-		{ imageUrl: "https://img.com/thumb.jpg", imageText: "Thumb", imageLabel: "color-thumbnail" },
-	];
-	const skuWithLabels = () => makeSku({ images: labelledImages });
-	const labelledProduct = () => makeProduct({ items: [skuWithLabels()] });
-
-	it("keeps the 2-image cap when keepImageNames is absent", () => {
-		const result = toProductShelf(labelledProduct(), skuWithLabels(), 0, options);
-		expect(result.image?.map((i) => i.name)).toEqual(["product-photo-0", "product-photo-1"]);
-	});
-
-	it("keepImageNames adds back labelled images that fall outside the cap", () => {
-		const result = toProductShelf(labelledProduct(), skuWithLabels(), 0, {
-			...options,
-			keepImageNames: ["secondary", "color-thumbnail"],
-		});
-		expect(result.image?.map((i) => i.name)).toEqual([
-			"product-photo-0",
-			"product-photo-1",
-			"secondary",
-			"color-thumbnail",
-		]);
-	});
-
-	it("keepImageNames does not duplicate a label already inside the cap", () => {
-		const result = toProductShelf(labelledProduct(), skuWithLabels(), 0, {
-			...options,
-			keepImageNames: ["product-photo-0", "secondary"],
-		});
-		expect(result.image?.map((i) => i.name)).toEqual([
-			"product-photo-0",
-			"product-photo-1",
-			"secondary",
-		]);
-	});
-
-	it("keepImageNames listing a label the SKU does not have changes nothing", () => {
-		const result = toProductShelf(labelledProduct(), skuWithLabels(), 0, {
-			...options,
-			keepImageNames: ["vira"],
-		});
-		expect(result.image?.map((i) => i.name)).toEqual(["product-photo-0", "product-photo-1"]);
-	});
-
-	it("maxImages overrides the shelf default cap", () => {
-		const result = toProductShelf(labelledProduct(), skuWithLabels(), 0, {
-			...options,
-			maxImages: 3,
-		});
-		expect(result.image).toHaveLength(3);
-	});
-});
-
-// ---------------------------------------------------------------------------
-// toProduct — escape hatches for leanVariants listings
-// ---------------------------------------------------------------------------
-//
-// `leanVariants` assumes the card renders the ROOT sku, so `buildOfferVariant`
-// empties `priceSpecification` on every `hasVariant[]` entry. A card that picks
-// a representative variant instead (e.g. "cheapest in stock") reads that
-// entry's own offer for list price and installments — blank with the ladder
-// emptied. `displayedVariantId` keeps exactly that one entry full.
-//
-// `maxImages` caps `image[]` by POSITION. Both default to undefined, which
-// preserves the previous output byte for byte — that is what the last two cases
-// pin down.
-
-describe("toProduct — displayedVariantId / maxImages", () => {
-	const sellers = (price: number) => [
-		{
-			sellerId: "1",
-			sellerName: "Seller One",
-			commertialOffer: {
-				AvailableQuantity: 5,
-				Price: price,
-				ListPrice: price + 30,
-				spotPrice: price,
-				PriceValidUntil: "2025-12-31",
-				// A real ladder: every payment method the store accepts, every
-				// installment count. Measured on a live listing: 46 rungs per SKU,
-				// 12.0 KB — the thing `leanOffer` exists to drop.
-				Installments: ["Visa", "Master", "Amex", "PIX"].flatMap((method) =>
-					Array.from({ length: 3 }, (_, i) => ({
-						Value: price / (i + 1),
-						NumberOfInstallments: i + 1,
-						Name: `${method} ${i + 1}x`,
-						InterestRate: 0,
-						TotalValuePlusInterestRate: price,
-						PaymentSystemName: method,
-					})),
-				),
-				GiftSkuIds: [],
-				teasers: [],
-			},
-		},
-	];
-
-	const makeSku = (itemId: string, price: number, imageCount = 4) =>
-		({
-			itemId,
-			name: `SKU ${itemId}`,
-			ean: "1234567890123",
-			referenceId: [{ Key: "RefId", Value: `REF-${itemId}` }],
-			images: Array.from({ length: imageCount }, (_, i) => ({
-				imageUrl: `https://img.com/${itemId}-${i}.jpg`,
-				imageText: `img${i}`,
-				imageLabel: `label${i}`,
-			})),
-			videos: [],
-			sellers: sellers(price),
-			variations: [{ name: "Cor", values: ["Preto"] }],
-			kitItems: [],
-			complementName: "",
-			estimatedDateArrival: null,
-			modalType: null,
-		}) as any;
-
-	const makeProduct = (items: any[]) =>
-		({
-			origin: "intelligent-search",
-			productId: "PROD1",
-			productName: "Test Product",
-			brand: "TestBrand",
-			brandId: 1,
-			brandImageUrl: null,
-			productReference: "REF1",
-			description: "desc",
-			releaseDate: "2024-01-01",
-			linkText: "test-product",
-			categories: ["/Electronics/"],
-			categoriesIds: ["/1/"],
-			categoryId: "1",
-			productClusters: [],
-			clusterHighlights: [],
-			items,
-		}) as any;
-
-	const options = { baseUrl: "https://example.com", priceCurrency: "BRL" };
-	const items = [makeSku("SKU1", 90), makeSku("SKU2", 60), makeSku("SKU3", 120)];
-	const product = makeProduct(items);
-
-	const ladderOf = (variant: any) => variant?.offers?.offers?.[0]?.priceSpecification ?? [];
-
-	/** Regra do caller: só os tipos base, nenhuma parcela. */
-	const onlyListAndSale = (specs: any[]) =>
-		specs.filter((s) => !s.priceComponentType);
-
-	it("leanVariants alone empties the payment ladder on every variant", () => {
-		const result = toProduct(product, items[0], 0, { ...options, leanVariants: true });
-		const variants = result.isVariantOf?.hasVariant ?? [];
-		expect(variants).toHaveLength(3);
-		for (const v of variants) expect(ladderOf(v)).toEqual([]);
-	});
-
-	it("displayedVariantId keeps the ladder on the ONE variant the card renders", () => {
-		const result = toProduct(product, items[0], 0, {
-			...options,
-			leanVariants: true,
-			displayedVariantId: (skus) => skus.find((s: any) => s.itemId === "SKU2")?.itemId,
-		});
-		const variants = result.isVariantOf?.hasVariant ?? [];
-		const kept = variants.find((v: any) => v.sku === "SKU2");
-		const lean = variants.filter((v: any) => v.sku !== "SKU2");
-
-		expect(ladderOf(kept).length).toBeGreaterThan(0);
-		for (const v of lean) expect(ladderOf(v)).toEqual([]);
-	});
-
-	it("the kept variant stays LEAN — only its offer is upgraded", () => {
-		const result = toProduct(product, items[0], 0, {
-			...options,
-			leanVariants: true,
-			displayedVariantId: () => "SKU2",
-		});
-		const kept: any = (result.isVariantOf?.hasVariant ?? []).find((v: any) => v.sku === "SKU2");
-
-		// A full toProduct here would re-emit these; the lean shape must not.
-		expect(kept.description).toBeUndefined();
-		expect(kept.brand).toBeUndefined();
-		expect(kept.gtin).toBeUndefined();
-		expect(kept.isVariantOf).toBeUndefined();
-		// ...but the ladder is real. Without a `priceSpecifications` rule it is
-		// the FULL one — dropping description/brand/isVariantOf is the win here,
-		// and the ladder stays whatever the caller asked for.
-		const full = ladderOf(toProduct(product, items[1], 0, options));
-		expect(ladderOf(kept).length).toBe(full.length);
-	});
-
-	it("the kept variant keeps its real inventoryLevel (selectors read it per SKU)", () => {
-		const result = toProduct(product, items[0], 0, {
-			...options,
-			leanVariants: true,
-			displayedVariantId: () => "SKU2",
-		});
-		const kept: any = (result.isVariantOf?.hasVariant ?? []).find((v: any) => v.sku === "SKU2");
-		// buildOfferShelf hard-zeroes inventoryLevel; the variant path must not
-		// inherit that, or every variant reads as out of stock.
-		expect(kept.offers?.offers?.[0]?.inventoryLevel?.value).toBe(5);
-	});
-
-	it("the ladder flag does NOT leak into the lean variants", () => {
-		// Regression: the internal `variantKeepLadder` reached `variantOptions`,
-		// so every lean variant emitted a ladder instead of an empty one and the
-		// option made the payload BIGGER — measured on a real listing,
-		// isVariantOf 38.6 -> 49.6 KB.
-		const result = toProduct(product, items[0], 0, {
-			...options,
-			leanVariants: true,
-			priceSpecifications: onlyListAndSale,
-			displayedVariantId: () => "SKU2",
-		});
-		const variants = result.isVariantOf?.hasVariant ?? [];
-		for (const v of variants.filter((v: any) => v.sku !== "SKU2")) {
-			expect(ladderOf(v)).toEqual([]);
-		}
-		expect(ladderOf(variants.find((v: any) => v.sku === "SKU2")).length).toBeGreaterThan(0);
-	});
-
-	it("priceSpecifications rewrites the ROOT ladder with the caller's own rule", () => {
-		const full = toProduct(product, items[0], 0, options);
-		const lean = toProduct(product, items[0], 0, {
-			...options,
-			priceSpecifications: onlyListAndSale,
-		});
-
-		expect(ladderOf(full).length).toBeGreaterThan(ladderOf(lean).length);
-		const types = new Set(ladderOf(lean).map((s: any) => s.priceType));
-		expect(types.has("https://schema.org/ListPrice")).toBe(true);
-		expect(types.has("https://schema.org/SalePrice")).toBe(true);
-	});
-
-	it("displayedVariantId returning undefined leaves every variant lean", () => {
-		const result = toProduct(product, items[0], 0, {
-			...options,
-			leanVariants: true,
-			displayedVariantId: () => undefined,
-		});
-		for (const v of result.isVariantOf?.hasVariant ?? []) expect(ladderOf(v)).toEqual([]);
-	});
-
-	it("maxImages caps image[] by position", () => {
-		const full = toProduct(product, items[0], 0, options);
-		expect(full.image).toHaveLength(4);
-
-		const capped = toProduct(product, items[0], 0, { ...options, maxImages: 2 });
-		expect(capped.image).toHaveLength(2);
-		expect(capped.image?.map((i) => i.url)).toEqual(
-			full.image?.slice(0, 2).map((i) => i.url),
-		);
-	});
-
-	it("keepImageNames rescues a labelled image from the maxImages cap", () => {
-		const capped = toProduct(product, items[0], 0, {
-			...options,
-			maxImages: 2,
-			keepImageNames: ["label3"],
-		});
-		expect(capped.image?.map((i) => i.name)).toEqual(["label0", "label1", "label3"]);
-	});
-
-	it("keepImageNames without maxImages is a no-op — every image is already there", () => {
-		const before = toProduct(product, items[0], 0, options);
-		const after = toProduct(product, items[0], 0, { ...options, keepImageNames: ["label3"] });
-		expect(JSON.stringify(after)).toBe(JSON.stringify(before));
-	});
-
-	it("every option absent is byte-for-byte the previous output", () => {
-		const before = toProduct(product, items[0], 0, options);
-		const after = toProduct(product, items[0], 0, {
-			...options,
-			displayedVariantId: undefined,
-			maxImages: undefined,
-			keepImageNames: undefined,
-			priceSpecifications: undefined,
-		});
-		expect(JSON.stringify(after)).toBe(JSON.stringify(before));
-	});
-});