@decocms/apps 0.23.3 → 0.25.0

package/vtex/utils/transform.ts

@@ -1,950 +1,1039 @@
 import type {
-  AggregateOffer,
-  Brand,
-  BreadcrumbList,
-  DayOfWeek,
-  Filter,
-  FilterToggleValue,
-  ItemAvailability,
-  Offer,
-  OpeningHoursSpecification,
-  PageType,
-  Place,
-  PostalAddress,
-  PriceComponentTypeEnumeration,
-  PriceTypeEnumeration,
-  Product,
-  ProductDetailsPage,
-  ProductGroup,
-  PropertyValue,
-  SiteNavigationElement,
-  UnitPriceSpecification,
+	AggregateOffer,
+	Brand,
+	BreadcrumbList,
+	DayOfWeek,
+	Filter,
+	FilterToggleValue,
+	ItemAvailability,
+	Offer,
+	OpeningHoursSpecification,
+	PageType,
+	Place,
+	PostalAddress,
+	PriceComponentTypeEnumeration,
+	PriceTypeEnumeration,
+	Product,
+	ProductDetailsPage,
+	ProductGroup,
+	PropertyValue,
+	SiteNavigationElement,
+	UnitPriceSpecification,
 } from "../../commerce/types/commerce";
 import { DEFAULT_IMAGE } from "../../commerce/utils/constants";
 import { formatRange } from "../../commerce/utils/filters";
 import { pick } from "./pickAndOmit";
 import { slugify } from "./slugify";
 import type {
-  Address,
-  Brand as BrandVTEX,
-  Category,
-  Facet as FacetVTEX,
-  FacetValueBoolean,
-  FacetValueRange,
-  Item as SkuVTEX,
-  LegacyFacet,
-  LegacyItem as LegacySkuVTEX,
-  LegacyProduct,
-  LegacyProduct as LegacyProductVTEX,
-  Maybe,
-  OrderForm,
-  PageType as PageTypeVTEX,
-  PickupHolidays,
-  PickupPoint,
-  Product as ProductVTEX,
-  ProductInventoryData,
-  ProductRating,
-  ProductReviewData,
-  SelectedFacet,
-  Seller as SellerVTEX,
-  Teasers,
+	Address,
+	Brand as BrandVTEX,
+	Category,
+	FacetValueBoolean,
+	FacetValueRange,
+	Facet as FacetVTEX,
+	LegacyFacet,
+	LegacyProduct,
+	LegacyProduct as LegacyProductVTEX,
+	LegacyItem as LegacySkuVTEX,
+	Maybe,
+	OrderForm,
+	PageType as PageTypeVTEX,
+	PickupHolidays,
+	PickupPoint,
+	ProductInventoryData,
+	ProductRating,
+	ProductReviewData,
+	Product as ProductVTEX,
+	SelectedFacet,
+	Seller as SellerVTEX,
+	Item as SkuVTEX,
+	Teasers,
 } from "./types";
 
 interface PickupPointVCS {
-  name?: string;
-  address?: {
-    country?: { acronym?: string };
-    location?: { latitude?: number; longitude?: number };
-    city?: string;
-    state?: string;
-    postalCode?: string;
-    street?: string;
-  };
-  pickupHolidays?: any[];
-  businessHours?: any[];
-  isActive?: boolean;
-  id?: string;
-  [key: string]: unknown;
+	name?: string;
+	address?: {
+		country?: { acronym?: string };
+		location?: { latitude?: number; longitude?: number };
+		city?: string;
+		state?: string;
+		postalCode?: string;
+		street?: string;
+	};
+	pickupHolidays?: any[];
+	businessHours?: any[];
+	isActive?: boolean;
+	id?: string;
+	[key: string]: unknown;
 }
 
 const DEFAULT_CATEGORY_SEPARATOR = ">";
 
-export const SCHEMA_LIST_PRICE: PriceTypeEnumeration =
-  "https://schema.org/ListPrice";
-export const SCHEMA_SALE_PRICE: PriceTypeEnumeration =
-  "https://schema.org/SalePrice";
+export const SCHEMA_LIST_PRICE: PriceTypeEnumeration = "https://schema.org/ListPrice";
+export const SCHEMA_SALE_PRICE: PriceTypeEnumeration = "https://schema.org/SalePrice";
 export const SCHEMA_SRP: PriceTypeEnumeration = "https://schema.org/SRP";
-export const SCHEMA_INSTALLMENT: PriceComponentTypeEnumeration =
-  "https://schema.org/Installment";
+export const SCHEMA_INSTALLMENT: PriceComponentTypeEnumeration = "https://schema.org/Installment";
 export const SCHEMA_IN_STOCK: ItemAvailability = "https://schema.org/InStock";
-export const SCHEMA_OUT_OF_STOCK: ItemAvailability =
-  "https://schema.org/OutOfStock";
+export const SCHEMA_OUT_OF_STOCK: ItemAvailability = "https://schema.org/OutOfStock";
 
 const isLegacySku = (sku: LegacySkuVTEX | SkuVTEX): sku is LegacySkuVTEX =>
-  typeof (sku as LegacySkuVTEX).variations?.[0] === "string" ||
-  !!(sku as LegacySkuVTEX).Videos;
-
-const isLegacyProduct = (
-  product: ProductVTEX | LegacyProductVTEX,
-): product is LegacyProductVTEX => product.origin !== "intelligent-search";
-
-const getProductGroupURL = (
-  origin: string,
-  { linkText }: { linkText: string },
-) => new URL(`/${linkText}/p`, origin);
-
-const getProductURL = (
-  origin: string,
-  product: { linkText: string },
-  skuId?: string,
-) => {
-  const canonicalUrl = getProductGroupURL(origin, product);
+	typeof (sku as LegacySkuVTEX).variations?.[0] === "string" || !!(sku as LegacySkuVTEX).Videos;
+
+const isLegacyProduct = (product: ProductVTEX | LegacyProductVTEX): product is LegacyProductVTEX =>
+	product.origin !== "intelligent-search";
+
+const getProductGroupURL = (origin: string, { linkText }: { linkText: string }) =>
+	new URL(`/${linkText}/p`, origin);
 
-  if (skuId) {
-    canonicalUrl.searchParams.set("skuId", skuId);
-  }
+const getProductURL = (origin: string, product: { linkText: string }, skuId?: string) => {
+	const canonicalUrl = getProductGroupURL(origin, product);
 
-  return canonicalUrl;
+	if (skuId) {
+		canonicalUrl.searchParams.set("skuId", skuId);
+	}
+
+	return canonicalUrl;
 };
 
-const nonEmptyArray = <T>(
-  array: T[] | null | undefined,
-) => (Array.isArray(array) && array.length > 0 ? array : null);
+const nonEmptyArray = <T>(array: T[] | null | undefined) =>
+	Array.isArray(array) && array.length > 0 ? array : null;
 
 interface ProductOptions {
-  baseUrl: string;
-  /** Price coded currency, e.g.: USD, BRL */
-  priceCurrency: string;
-  imagesByKey?: Map<string, string>;
-  /** Original attributes to be included in the transformed product */
-  includeOriginalAttributes?: string[];
+	baseUrl: string;
+	/** Price coded currency, e.g.: USD, BRL */
+	priceCurrency: string;
+	imagesByKey?: Map<string, string>;
+	/** Original attributes to be included in the transformed product */
+	includeOriginalAttributes?: string[];
 }
 
 /** Returns first available sku */
 const findFirstAvailable = (items: Array<LegacySkuVTEX | SkuVTEX>) =>
-  items?.find((item) =>
-    Boolean(
-      item?.sellers?.find((s) => s.commertialOffer?.AvailableQuantity > 0),
-    )
-  );
+	items?.find((item) =>
+		Boolean(item?.sellers?.find((s) => s.commertialOffer?.AvailableQuantity > 0)),
+	);
 
 export const pickSku = <T extends ProductVTEX | LegacyProductVTEX>(
-  product: T,
-  maybeSkuId?: string,
+	product: T,
+	maybeSkuId?: string,
 ): T["items"][number] => {
-  const skuId = maybeSkuId ?? findFirstAvailable(product.items)?.itemId ??
-    product.items[0]?.itemId;
-  for (const item of product.items) {
-    if (item.itemId === skuId) {
-      return item;
-    }
-  }
-
-  return product.items[0];
+	const skuId = maybeSkuId ?? findFirstAvailable(product.items)?.itemId ?? product.items[0]?.itemId;
+	for (const item of product.items) {
+		if (item.itemId === skuId) {
+			return item;
+		}
+	}
+
+	return product.items[0];
 };
 
 const toAccessoryOrSparePartFor = <T extends ProductVTEX | LegacyProductVTEX>(
-  sku: T["items"][number],
-  kitItems: T[],
-  options: ProductOptions,
+	sku: T["items"][number],
+	kitItems: T[],
+	options: ProductOptions,
 ) => {
-  const productBySkuId = kitItems.reduce((map, product) => {
-    product.items.forEach((item) => map.set(item.itemId, product));
+	const productBySkuId = kitItems.reduce((map, product) => {
+		product.items.forEach((item) => map.set(item.itemId, product));
 
-    return map;
-  }, new Map<string, T>());
+		return map;
+	}, new Map<string, T>());
 
-  return sku.kitItems
-    ?.map(({ itemId }) => {
-      const product = productBySkuId.get(itemId);
+	return sku.kitItems
+		?.map(({ itemId }) => {
+			const product = productBySkuId.get(itemId);
 
-      /** Sometimes VTEX does not return what I've asked for */
-      if (!product) return;
+			/** Sometimes VTEX does not return what I've asked for */
+			if (!product) return;
 
-      const sku = pickSku(product, itemId);
+			const sku = pickSku(product, itemId);
 
-      return toProduct(product, sku, 0, options);
-    })
-    .filter((p): p is Product => typeof p !== "undefined");
+			return toProduct(product, sku, 0, options);
+		})
+		.filter((p): p is Product => typeof p !== "undefined");
 };
 
 export const forceHttpsOnAssets = (orderForm: OrderForm) => {
-  orderForm.items.forEach((item) => {
-    if (item.imageUrl) {
-      item.imageUrl = item.imageUrl.startsWith("http://")
-        ? item.imageUrl.replace("http://", "https://")
-        : item.imageUrl;
-    }
-  });
-  return orderForm;
+	orderForm.items.forEach((item) => {
+		if (item.imageUrl) {
+			item.imageUrl = item.imageUrl.startsWith("http://")
+				? item.imageUrl.replace("http://", "https://")
+				: item.imageUrl;
+		}
+	});
+	return orderForm;
 };
 
 export const toProductPage = <T extends ProductVTEX | LegacyProductVTEX>(
-  product: T,
-  sku: T["items"][number],
-  kitItems: T[],
-  options: ProductOptions,
+	product: T,
+	sku: T["items"][number],
+	kitItems: T[],
+	options: ProductOptions,
 ): Omit<ProductDetailsPage, "seo"> => {
-  const partialProduct = toProduct(product, sku, 0, options);
-  // This is deprecated. Compose this loader at loaders > product > extension > detailsPage.ts
-  const isAccessoryOrSparePartFor = toAccessoryOrSparePartFor(
-    sku,
-    kitItems,
-    options,
-  );
-
-  return {
-    "@type": "ProductDetailsPage",
-    breadcrumbList: toBreadcrumbList(product, options),
-    product: { ...partialProduct, isAccessoryOrSparePartFor },
-  };
+	const partialProduct = toProduct(product, sku, 0, options);
+	// This is deprecated. Compose this loader at loaders > product > extension > detailsPage.ts
+	const isAccessoryOrSparePartFor = toAccessoryOrSparePartFor(sku, kitItems, options);
+
+	return {
+		"@type": "ProductDetailsPage",
+		breadcrumbList: toBreadcrumbList(product, options),
+		product: { ...partialProduct, isAccessoryOrSparePartFor },
+	};
 };
 
 export const inStock = (offer: Offer) => offer.availability === SCHEMA_IN_STOCK;
 
 // Smallest Available Spot Price First
 export const bestOfferFirst = (a: Offer, b: Offer) => {
-  if (inStock(a) && !inStock(b)) {
-    return -1;
-  }
+	if (inStock(a) && !inStock(b)) {
+		return -1;
+	}
 
-  if (!inStock(a) && inStock(b)) {
-    return 1;
-  }
+	if (!inStock(a) && inStock(b)) {
+		return 1;
+	}
 
-  return a.price - b.price;
+	return a.price - b.price;
 };
 
 const getHighPriceIndex = (offers: Offer[]) => {
-  let it = offers.length - 1;
-  for (; it > 0 && !inStock(offers[it]); it--);
-  return it;
+	let it = offers.length - 1;
+	for (; it > 0 && !inStock(offers[it]); it--);
+	return it;
 };
 
-const splitCategory = (firstCategory: string) =>
-  firstCategory.split("/").filter(Boolean);
+const splitCategory = (firstCategory: string) => firstCategory.split("/").filter(Boolean);
 
-const toAdditionalPropertyCategories = <
-  P extends LegacyProductVTEX | ProductVTEX,
->(
-  product: P,
+const toAdditionalPropertyCategories = <P extends LegacyProductVTEX | ProductVTEX>(
+	product: P,
 ): Product["additionalProperty"] => {
-  const categories = new Set<string>();
-  const categoryIds = new Set<string>();
-
-  product.categories.forEach((productCategory, i) => {
-    const category = splitCategory(productCategory);
-    const categoryId = splitCategory(product.categoriesIds[i]);
-
-    category.forEach((splitCategoryItem, j) => {
-      categories.add(splitCategoryItem);
-      categoryIds.add(categoryId[j]);
-    });
-  });
-
-  const categoriesArray = Array.from(categories);
-  const categoryIdsArray = Array.from(categoryIds);
-
-  return categoriesArray.map((category, index) =>
-    toAdditionalPropertyCategory({
-      propertyID: categoryIdsArray[index],
-      value: category || "",
-    })
-  );
+	const categories = new Set<string>();
+	const categoryIds = new Set<string>();
+
+	product.categories.forEach((productCategory, i) => {
+		const category = splitCategory(productCategory);
+		const categoryId = splitCategory(product.categoriesIds[i]);
+
+		category.forEach((splitCategoryItem, j) => {
+			categories.add(splitCategoryItem);
+			categoryIds.add(categoryId[j]);
+		});
+	});
+
+	const categoriesArray = Array.from(categories);
+	const categoryIdsArray = Array.from(categoryIds);
+
+	return categoriesArray.map((category, index) =>
+		toAdditionalPropertyCategory({
+			propertyID: categoryIdsArray[index],
+			value: category || "",
+		}),
+	);
 };
 
 export const toAdditionalPropertyCategory = ({
-  propertyID,
-  value,
+	propertyID,
+	value,
 }: {
-  propertyID: string;
-  value: string;
+	propertyID: string;
+	value: string;
 }): PropertyValue => ({
-  "@type": "PropertyValue" as const,
-  name: "category",
-  propertyID,
-  value,
+	"@type": "PropertyValue" as const,
+	name: "category",
+	propertyID,
+	value,
 });
 
-const toAdditionalPropertyClusters = <
-  P extends LegacyProductVTEX | ProductVTEX,
->(
-  product: P,
+const toAdditionalPropertyClusters = <P extends LegacyProductVTEX | ProductVTEX>(
+	product: P,
 ): Product["additionalProperty"] => {
-  const mapEntriesToIdName = ([id, name]: [string, unknown]) => ({
-    id,
-    name: name as string,
-  });
-
-  const allClusters = isLegacyProduct(product)
-    ? Object.entries(product.productClusters).map(mapEntriesToIdName)
-    : product.productClusters;
-
-  const highlightsSet = isLegacyProduct(product)
-    ? new Set(Object.keys(product.clusterHighlights))
-    : new Set(product.clusterHighlights.map(({ id }) => id));
-
-  return allClusters.map((cluster) =>
-    toAdditionalPropertyCluster({
-      propertyID: cluster.id,
-      value: cluster.name || "",
-    }, highlightsSet)
-  );
+	const mapEntriesToIdName = ([id, name]: [string, unknown]) => ({
+		id,
+		name: name as string,
+	});
+
+	const allClusters = isLegacyProduct(product)
+		? Object.entries(product.productClusters).map(mapEntriesToIdName)
+		: product.productClusters;
+
+	const highlightsSet = isLegacyProduct(product)
+		? new Set(Object.keys(product.clusterHighlights))
+		: new Set(product.clusterHighlights.map(({ id }) => id));
+
+	return allClusters.map((cluster) =>
+		toAdditionalPropertyCluster(
+			{
+				propertyID: cluster.id,
+				value: cluster.name || "",
+			},
+			highlightsSet,
+		),
+	);
 };
 
 export const toAdditionalPropertyCluster = (
-  { propertyID, value }: { propertyID: string; value: string },
-  highlights?: Set<string>,
+	{ propertyID, value }: { propertyID: string; value: string },
+	highlights?: Set<string>,
 ): PropertyValue => ({
-  "@type": "PropertyValue",
-  name: "cluster",
-  value,
-  propertyID,
-  description: highlights?.has(propertyID) ? "highlight" : undefined,
+	"@type": "PropertyValue",
+	name: "cluster",
+	value,
+	propertyID,
+	description: highlights?.has(propertyID) ? "highlight" : undefined,
 });
 
 const toAdditionalPropertyReferenceIds = (
-  referenceId: Array<{ Key: string; Value: string }>,
+	referenceId: Array<{ Key: string; Value: string }>,
 ): Product["additionalProperty"] => {
-  return referenceId.map(({ Key, Value }) =>
-    toAdditionalPropertyReferenceId({ name: Key, value: Value })
-  );
+	return referenceId.map(({ Key, Value }) =>
+		toAdditionalPropertyReferenceId({ name: Key, value: Value }),
+	);
 };
 
 export const toAdditionalPropertyReferenceId = ({
-  name,
-  value,
+	name,
+	value,
 }: {
-  name: string;
-  value: string;
+	name: string;
+	value: string;
 }): PropertyValue => ({
-  "@type": "PropertyValue",
-  name,
-  value,
-  valueReference: "ReferenceID",
+	"@type": "PropertyValue",
+	name,
+	value,
+	valueReference: "ReferenceID",
 });
 
 const getImageKey = (src = "") => {
-  return src;
+	return src;
 
-  // TODO: figure out how we can improve this
-  // const match = new URLPattern({
-  //   pathname: "/arquivos/ids/:skuId/:imageId",
-  // }).exec(src);
+	// TODO: figure out how we can improve this
+	// const match = new URLPattern({
+	//   pathname: "/arquivos/ids/:skuId/:imageId",
+	// }).exec(src);
 
-  // if (match == null) {
-  //   return src;
-  // }
+	// if (match == null) {
+	//   return src;
+	// }
 
-  // return `${match.pathname.groups.imageId}${match.search.input}`;
+	// return `${match.pathname.groups.imageId}${match.search.input}`;
 };
 
 export const aggregateOffers = (
-  offers: Offer[],
-  priceCurrency?: string,
+	offers: Offer[],
+	priceCurrency?: string,
 ): AggregateOffer | undefined => {
-  const sorted = offers.sort(bestOfferFirst);
+	const sorted = offers.sort(bestOfferFirst);
 
-  if (sorted.length === 0) return;
+	if (sorted.length === 0) return;
 
-  const highPriceIndex = getHighPriceIndex(sorted);
-  const lowPriceIndex = 0;
+	const highPriceIndex = getHighPriceIndex(sorted);
+	const lowPriceIndex = 0;
 
-  return {
-    "@type": "AggregateOffer",
-    priceCurrency,
-    highPrice: sorted[highPriceIndex]?.price ?? null,
-    lowPrice: sorted[lowPriceIndex]?.price ?? null,
-    offerCount: sorted.length,
-    offers: sorted,
-  };
+	return {
+		"@type": "AggregateOffer",
+		priceCurrency,
+		highPrice: sorted[highPriceIndex]?.price ?? null,
+		lowPrice: sorted[lowPriceIndex]?.price ?? null,
+		offerCount: sorted.length,
+		offers: sorted,
+	};
 };
 
 export const toProduct = <P extends LegacyProductVTEX | ProductVTEX>(
-  product: P,
-  sku: P["items"][number],
-  level = 0, // prevent inifinte loop while self referencing the product
-  options: ProductOptions,
+	product: P,
+	sku: P["items"][number],
+	level = 0, // prevent inifinte loop while self referencing the product
+	options: ProductOptions,
+): Product => {
+	const { baseUrl, priceCurrency } = options;
+	const {
+		brand,
+		brandId,
+		brandImageUrl,
+		productId,
+		productReference,
+		description,
+		releaseDate,
+		items,
+	} = product;
+	const { name, ean, itemId: skuId, referenceId = [], kitItems, estimatedDateArrival } = sku;
+
+	const videos = isLegacySku(sku) ? sku.Videos : sku.videos;
+	const nonEmptyVideos = nonEmptyArray(videos);
+	const imagesByKey =
+		options.imagesByKey ??
+		items
+			.flatMap((i) => i.images)
+			.reduce((map, img) => {
+				img?.imageUrl && map.set(getImageKey(img.imageUrl), img.imageUrl);
+				return map;
+			}, new Map<string, string>());
+
+	const groupAdditionalProperty = isLegacyProduct(product)
+		? legacyToProductGroupAdditionalProperties(product)
+		: toProductGroupAdditionalProperties(product);
+	const originalAttributesAdditionalProperties = toOriginalAttributesAdditionalProperties(
+		options.includeOriginalAttributes,
+		product,
+	);
+	const specificationsAdditionalProperty = isLegacySku(sku)
+		? toAdditionalPropertiesLegacy(sku)
+		: toAdditionalProperties(sku);
+	const referenceIdAdditionalProperty = toAdditionalPropertyReferenceIds(referenceId);
+	const images = nonEmptyArray(sku.images);
+	const offers = (sku.sellers ?? []).map(isLegacyProduct(product) ? toOfferLegacy : toOffer);
+
+	const variantOptions =
+		imagesByKey !== options.imagesByKey ? { ...options, imagesByKey } : options;
+	const isVariantOf =
+		level < 1
+			? ({
+					"@type": "ProductGroup",
+					productGroupID: productId,
+					hasVariant: items.map((sku) => toProduct(product, sku, 1, variantOptions)),
+					url: getProductGroupURL(baseUrl, product).href,
+					name: product.productName,
+					additionalProperty: [
+						...groupAdditionalProperty,
+						...originalAttributesAdditionalProperties,
+					],
+					model: productReference,
+				} satisfies ProductGroup)
+			: undefined;
+
+	const finalImages = images?.map(({ imageUrl, imageText, imageLabel }) => {
+		const url = imagesByKey.get(getImageKey(imageUrl)) ?? imageUrl;
+		const alternateName = imageText || imageLabel || "";
+		const name = imageLabel || "";
+		const encodingFormat = "image";
+
+		return {
+			"@type": "ImageObject" as const,
+			alternateName,
+			url,
+			name,
+			encodingFormat,
+		};
+	}) ?? [DEFAULT_IMAGE];
+
+	const finalVideos = nonEmptyVideos?.map((video) => {
+		const url = video;
+		const alternateName = "Product video";
+		const name = "Product video";
+		const encodingFormat = "video";
+		return {
+			"@type": "VideoObject" as const,
+			alternateName,
+			contentUrl: url,
+			name,
+			encodingFormat,
+		};
+	});
+
+	// From schema.org: A category for the item. Greater signs or slashes can be used to informally indicate a category hierarchy
+	const categoriesString = splitCategory(product.categories[0]).join(DEFAULT_CATEGORY_SEPARATOR);
+
+	const categoryAdditionalProperties = toAdditionalPropertyCategories(product);
+	const clusterAdditionalProperties = toAdditionalPropertyClusters(product);
+
+	const additionalProperty: PropertyValue[] = [...specificationsAdditionalProperty];
+	if (categoryAdditionalProperties) {
+		additionalProperty.push(...categoryAdditionalProperties);
+	}
+	if (clusterAdditionalProperties) {
+		additionalProperty.push(...clusterAdditionalProperties);
+	}
+	if (referenceIdAdditionalProperty) {
+		additionalProperty.push(...referenceIdAdditionalProperty);
+	}
+
+	estimatedDateArrival &&
+		additionalProperty.push({
+			"@type": "PropertyValue",
+			name: "Estimated Date Arrival",
+			value: estimatedDateArrival,
+		});
+
+	if (sku.modalType) {
+		additionalProperty.push({
+			"@type": "PropertyValue",
+			name: "Modal Type",
+			value: sku.modalType,
+		});
+	}
+
+	return {
+		"@type": "Product",
+		category: categoriesString,
+		productID: skuId,
+		url: getProductURL(baseUrl, product, sku.itemId).href,
+		name,
+		alternateName: sku.complementName,
+		description,
+		brand: {
+			"@type": "Brand",
+			"@id": brandId?.toString(),
+			name: brand,
+			logo: brandImageUrl,
+		},
+		isAccessoryOrSparePartFor: kitItems?.map(({ itemId }) => ({
+			"@type": "Product",
+			productID: itemId,
+			sku: itemId,
+		})),
+		inProductGroupWithID: productId,
+		sku: skuId,
+		gtin: ean,
+		releaseDate,
+		additionalProperty,
+		isVariantOf,
+		image: finalImages,
+		video: finalVideos,
+		offers: aggregateOffers(offers, priceCurrency),
+	};
+};
+
+/**
+ * Determines if an installment has no interest by checking if
+ * billingDuration * billingIncrement ≈ total price (within 1 cent tolerance).
+ */
+const isNoInterest = (spec: UnitPriceSpecification): boolean => {
+	if (spec.billingDuration == null || spec.billingIncrement == null || spec.price == null) {
+		return false;
+	}
+	return Math.abs(spec.billingDuration * spec.billingIncrement - spec.price) < 0.01;
+};
+
+/**
+ * Build a lean offer for shelf display. Keeps only:
+ * - ListPrice, SalePrice, SRP price types
+ * - PIX installment (name?.toUpperCase() === "PIX")
+ * - Best no-interest installment (highest billingDuration)
+ * Drops: inventoryLevel, giftSkuIds, priceValidUntil
+ */
+const buildOfferShelf = (offer: Offer): Offer => {
+	const leanSpecs: UnitPriceSpecification[] = [];
+
+	let bestNoInterest: UnitPriceSpecification | null = null;
+
+	for (const spec of offer.priceSpecification ?? []) {
+		// Keep base price types
+		if (
+			spec.priceType === SCHEMA_LIST_PRICE ||
+			spec.priceType === SCHEMA_SALE_PRICE ||
+			spec.priceType === SCHEMA_SRP
+		) {
+			if (spec.priceComponentType !== SCHEMA_INSTALLMENT) {
+				leanSpecs.push(spec);
+				continue;
+			}
+		}
+
+		// Keep PIX installment
+		if (spec.priceComponentType === SCHEMA_INSTALLMENT && spec.name?.toUpperCase() === "PIX") {
+			leanSpecs.push(spec);
+			continue;
+		}
+
+		// Track best no-interest installment (highest billingDuration)
+		if (
+			spec.priceComponentType === SCHEMA_INSTALLMENT &&
+			isNoInterest(spec) &&
+			(bestNoInterest == null ||
+				(spec.billingDuration ?? 0) > (bestNoInterest.billingDuration ?? 0))
+		) {
+			bestNoInterest = spec;
+		}
+	}
+
+	if (bestNoInterest) {
+		leanSpecs.push(bestNoInterest);
+	}
+
+	return {
+		"@type": "Offer",
+		identifier: offer.identifier,
+		price: offer.price,
+		seller: offer.seller,
+		sellerName: offer.sellerName,
+		teasers: offer.teasers,
+		priceSpecification: leanSpecs,
+		availability: offer.availability,
+		inventoryLevel: { value: 0 },
+	};
+};
+
+/** Property names commonly used by ProductCard/Shelf components */
+const SHELF_PROPERTY_NAMES = new Set([
+	"category",
+	"cluster",
+	"Cor",
+	"Tamanho",
+	"Voltagem",
+	"sellerId",
+]);
+
+/**
+ * Lean product transform for shelf/card display. Same signature as toProduct().
+ *
+ * Differences from toProduct():
+ * - Images: capped at 2 per SKU (front + back)
+ * - Offers: first seller only, stripped installments (keeps ListPrice, SalePrice, SRP, PIX, best no-interest)
+ * - isVariantOf: single in-stock variant at level 0
+ * - additionalProperty: filtered to known-used property names
+ * - Drops: description, video, isAccessoryOrSparePartFor, alternateName, gtin, releaseDate, model
+ */
+export const toProductShelf = <P extends LegacyProductVTEX | ProductVTEX>(
+	product: P,
+	sku: P["items"][number],
+	level = 0,
+	options: ProductOptions,
 ): Product => {
-  const { baseUrl, priceCurrency } = options;
-  const {
-    brand,
-    brandId,
-    brandImageUrl,
-    productId,
-    productReference,
-    description,
-    releaseDate,
-    items,
-  } = product;
-  const {
-    name,
-    ean,
-    itemId: skuId,
-    referenceId = [],
-    kitItems,
-    estimatedDateArrival,
-  } = sku;
-
-  const videos = isLegacySku(sku) ? sku.Videos : sku.videos;
-  const nonEmptyVideos = nonEmptyArray(videos);
-  const imagesByKey = options.imagesByKey ??
-    items
-      .flatMap((i) => i.images)
-      .reduce((map, img) => {
-        img?.imageUrl && map.set(getImageKey(img.imageUrl), img.imageUrl);
-        return map;
-      }, new Map<string, string>());
-
-  const groupAdditionalProperty = isLegacyProduct(product)
-    ? legacyToProductGroupAdditionalProperties(product)
-    : toProductGroupAdditionalProperties(product);
-  const originalAttributesAdditionalProperties =
-    toOriginalAttributesAdditionalProperties(
-      options.includeOriginalAttributes,
-      product,
-    );
-  const specificationsAdditionalProperty = isLegacySku(sku)
-    ? toAdditionalPropertiesLegacy(sku)
-    : toAdditionalProperties(sku);
-  const referenceIdAdditionalProperty = toAdditionalPropertyReferenceIds(
-    referenceId,
-  );
-  const images = nonEmptyArray(sku.images);
-  const offers = (sku.sellers ?? []).map(
-    isLegacyProduct(product) ? toOfferLegacy : toOffer,
-  );
-
-  const variantOptions = imagesByKey !== options.imagesByKey
-    ? { ...options, imagesByKey }
-    : options;
-  const isVariantOf = level < 1
-    ? ({
-      "@type": "ProductGroup",
-      productGroupID: productId,
-      hasVariant: items.map((sku) =>
-        toProduct(product, sku, 1, variantOptions)
-      ),
-      url: getProductGroupURL(baseUrl, product).href,
-      name: product.productName,
-      additionalProperty: [
-        ...groupAdditionalProperty,
-        ...originalAttributesAdditionalProperties,
-      ],
-      model: productReference,
-    } satisfies ProductGroup)
-    : undefined;
-
-  const finalImages = images?.map(({ imageUrl, imageText, imageLabel }) => {
-    const url = imagesByKey.get(getImageKey(imageUrl)) ?? imageUrl;
-    const alternateName = imageText || imageLabel || "";
-    const name = imageLabel || "";
-    const encodingFormat = "image";
-
-    return {
-      "@type": "ImageObject" as const,
-      alternateName,
-      url,
-      name,
-      encodingFormat,
-    };
-  }) ?? [DEFAULT_IMAGE];
-
-  const finalVideos = nonEmptyVideos?.map((video) => {
-    const url = video;
-    const alternateName = "Product video";
-    const name = "Product video";
-    const encodingFormat = "video";
-    return {
-      "@type": "VideoObject" as const,
-      alternateName,
-      contentUrl: url,
-      name,
-      encodingFormat,
-    };
-  });
-
-  // From schema.org: A category for the item. Greater signs or slashes can be used to informally indicate a category hierarchy
-  const categoriesString = splitCategory(product.categories[0]).join(
-    DEFAULT_CATEGORY_SEPARATOR,
-  );
-
-  const categoryAdditionalProperties = toAdditionalPropertyCategories(product);
-  const clusterAdditionalProperties = toAdditionalPropertyClusters(product);
-
-  const additionalProperty: PropertyValue[] = [
-    ...specificationsAdditionalProperty,
-  ];
-  if (categoryAdditionalProperties) {
-    additionalProperty.push(...categoryAdditionalProperties);
-  }
-  if (clusterAdditionalProperties) {
-    additionalProperty.push(...clusterAdditionalProperties);
-  }
-  if (referenceIdAdditionalProperty) {
-    additionalProperty.push(...referenceIdAdditionalProperty);
-  }
-
-  estimatedDateArrival && additionalProperty.push({
-    "@type": "PropertyValue",
-    name: "Estimated Date Arrival",
-    value: estimatedDateArrival,
-  });
-
-  if (sku.modalType) {
-    additionalProperty.push({
-      "@type": "PropertyValue",
-      name: "Modal Type",
-      value: sku.modalType,
-    });
-  }
-
-  return {
-    "@type": "Product",
-    category: categoriesString,
-    productID: skuId,
-    url: getProductURL(baseUrl, product, sku.itemId).href,
-    name,
-    alternateName: sku.complementName,
-    description,
-    brand: {
-      "@type": "Brand",
-      "@id": brandId?.toString(),
-      name: brand,
-      logo: brandImageUrl,
-    },
-    isAccessoryOrSparePartFor: kitItems?.map(({ itemId }) => ({
-      "@type": "Product",
-      productID: itemId,
-      sku: itemId,
-    })),
-    inProductGroupWithID: productId,
-    sku: skuId,
-    gtin: ean,
-    releaseDate,
-    additionalProperty,
-    isVariantOf,
-    image: finalImages,
-    video: finalVideos,
-    offers: aggregateOffers(offers, priceCurrency),
-  };
+	const { baseUrl, priceCurrency } = options;
+	const { productId, items } = product;
+	const { name, itemId: skuId } = sku;
+
+	// Images: cap at 2
+	const rawImages = nonEmptyArray(sku.images);
+	const mappedImages = (rawImages ?? []).slice(0, 2).map(({ imageUrl, imageText, imageLabel }) => ({
+		"@type": "ImageObject" as const,
+		alternateName: imageText || imageLabel || "",
+		url: imageUrl,
+		name: imageLabel || "",
+		encodingFormat: "image",
+	}));
+	const finalImages = mappedImages.length > 0 ? mappedImages : [DEFAULT_IMAGE];
+
+	// Offers: first seller only, lean
+	const firstSeller = (sku.sellers ?? [])[0];
+	const fullOffer = firstSeller
+		? (isLegacyProduct(product) ? toOfferLegacy : toOffer)(firstSeller)
+		: undefined;
+	const leanOffers = fullOffer ? [buildOfferShelf(fullOffer)] : [];
+
+	// isVariantOf: single in-stock variant at level 0
+	const isVariantOf =
+		level < 1
+			? (() => {
+					const inStockSku = findFirstAvailable(items) ?? items[0];
+					const singleVariant = inStockSku ? [toProductShelf(product, inStockSku, 1, options)] : [];
+					return {
+						"@type": "ProductGroup" as const,
+						productGroupID: productId,
+						hasVariant: singleVariant,
+						url: getProductGroupURL(baseUrl, product).href,
+						name: product.productName,
+						additionalProperty: [],
+					} satisfies ProductGroup;
+				})()
+			: undefined;
+
+	// additionalProperty: filter to known-used names
+	const specificationsAdditionalProperty = isLegacySku(sku)
+		? toAdditionalPropertiesLegacy(sku)
+		: toAdditionalProperties(sku);
+	const categoryAdditionalProperties = toAdditionalPropertyCategories(product) ?? [];
+	const clusterAdditionalProperties = toAdditionalPropertyClusters(product) ?? [];
+
+	const additionalProperty = [
+		...specificationsAdditionalProperty,
+		...categoryAdditionalProperties,
+		...clusterAdditionalProperties,
+	].filter((prop) => SHELF_PROPERTY_NAMES.has(prop.name ?? ""));
+
+	const categoriesString = splitCategory(product.categories[0]).join(DEFAULT_CATEGORY_SEPARATOR);
+
+	return {
+		"@type": "Product",
+		category: categoriesString,
+		productID: skuId,
+		url: getProductURL(baseUrl, product, sku.itemId).href,
+		name,
+		brand: { "@type": "Brand", name: product.brand },
+		inProductGroupWithID: productId,
+		sku: skuId,
+		image: finalImages,
+		offers: aggregateOffers(leanOffers, priceCurrency),
+		isVariantOf,
+		additionalProperty,
+	};
 };
 
 const toBreadcrumbList = (
-  product: ProductVTEX | LegacyProductVTEX,
-  { baseUrl }: ProductOptions,
+	product: ProductVTEX | LegacyProductVTEX,
+	{ baseUrl }: ProductOptions,
 ): BreadcrumbList => {
-  const { categories, productName } = product;
-  const names = categories[0]?.split("/").filter(Boolean);
-
-  const segments = names.map(slugify);
-
-  return {
-    "@type": "BreadcrumbList",
-    itemListElement: [
-      ...names.map((name, index) => {
-        const position = index + 1;
-
-        return {
-          "@type": "ListItem" as const,
-          name,
-          item:
-            new URL(`/${segments.slice(0, position).join("/")}`, baseUrl).href,
-          position,
-        };
-      }),
-      {
-        "@type": "ListItem",
-        name: productName,
-        item: getProductGroupURL(baseUrl, product).href,
-        position: categories.length + 1,
-      },
-    ],
-    numberOfItems: categories.length + 1,
-  };
+	const { categories, productName } = product;
+	const names = categories[0]?.split("/").filter(Boolean);
+
+	const segments = names.map(slugify);
+
+	return {
+		"@type": "BreadcrumbList",
+		itemListElement: [
+			...names.map((name, index) => {
+				const position = index + 1;
+
+				return {
+					"@type": "ListItem" as const,
+					name,
+					item: new URL(`/${segments.slice(0, position).join("/")}`, baseUrl).href,
+					position,
+				};
+			}),
+			{
+				"@type": "ListItem",
+				name: productName,
+				item: getProductGroupURL(baseUrl, product).href,
+				position: categories.length + 1,
+			},
+		],
+		numberOfItems: categories.length + 1,
+	};
 };
 
-const legacyToProductGroupAdditionalProperties = (
-  product: LegacyProductVTEX,
-) => {
-  const groups = product.allSpecificationsGroups ?? [];
-  const allSpecifications = product.allSpecifications ?? [];
-
-  const specByGroup: Record<string, string> = {};
-
-  groups.forEach((group) => {
-    const groupSpecs = (product as unknown as Record<string, string[]>)[group];
-    groupSpecs.forEach((specName) => {
-      specByGroup[specName] = group;
-    });
-  });
-
-  return allSpecifications.flatMap((name) => {
-    const values = (product as unknown as Record<string, string[]>)[name];
-    return values.map((value) =>
-      toAdditionalPropertySpecification({
-        name,
-        value,
-        propertyID: specByGroup[name],
-      })
-    );
-  });
+const legacyToProductGroupAdditionalProperties = (product: LegacyProductVTEX) => {
+	const groups = product.allSpecificationsGroups ?? [];
+	const allSpecifications = product.allSpecifications ?? [];
+
+	const specByGroup: Record<string, string> = {};
+
+	groups.forEach((group) => {
+		const groupSpecs = (product as unknown as Record<string, string[]>)[group];
+		groupSpecs.forEach((specName) => {
+			specByGroup[specName] = group;
+		});
+	});
+
+	return allSpecifications.flatMap((name) => {
+		const values = (product as unknown as Record<string, string[]>)[name];
+		return values.map((value) =>
+			toAdditionalPropertySpecification({
+				name,
+				value,
+				propertyID: specByGroup[name],
+			}),
+		);
+	});
 };
 
-const toProductGroupAdditionalProperties = (
-  { specificationGroups = [] }: ProductVTEX,
-) =>
-  specificationGroups.flatMap(({ name: groupName, specifications }) =>
-    specifications.flatMap(({ name, values }) =>
-      values.map(
-        (value) =>
-          ({
-            "@type": "PropertyValue",
-            name,
-            value,
-            propertyID: groupName,
-            valueReference: "PROPERTY" as string,
-          }) as const,
-      )
-    )
-  );
+const toProductGroupAdditionalProperties = ({ specificationGroups = [] }: ProductVTEX) =>
+	specificationGroups.flatMap(({ name: groupName, specifications }) =>
+		specifications.flatMap(({ name, values }) =>
+			values.map(
+				(value) =>
+					({
+						"@type": "PropertyValue",
+						name,
+						value,
+						propertyID: groupName,
+						valueReference: "PROPERTY" as string,
+					}) as const,
+			),
+		),
+	);
 
 const toOriginalAttributesAdditionalProperties = (
-  originalAttributes: Maybe<string[]>,
-  product: ProductVTEX | LegacyProduct,
+	originalAttributes: Maybe<string[]>,
+	product: ProductVTEX | LegacyProduct,
 ) => {
-  if (!originalAttributes) {
-    return [];
-  }
-
-  const attributes =
-    pick(originalAttributes as Array<keyof typeof product>, product) ?? {};
-
-  return Object.entries(attributes).map(([name, value]) =>
-    ({
-      "@type": "PropertyValue",
-      name,
-      value,
-      valueReference: "ORIGINAL_PROPERTY" as string,
-    }) as const
-  ) as unknown as PropertyValue[];
+	if (!originalAttributes) {
+		return [];
+	}
+
+	const attributes = pick(originalAttributes as Array<keyof typeof product>, product) ?? {};
+
+	return Object.entries(attributes).map(
+		([name, value]) =>
+			({
+				"@type": "PropertyValue",
+				name,
+				value,
+				valueReference: "ORIGINAL_PROPERTY" as string,
+			}) as const,
+	) as unknown as PropertyValue[];
 };
 
 const toAdditionalProperties = (sku: SkuVTEX): PropertyValue[] =>
-  sku.variations?.flatMap(({ name, values }) =>
-    values.map((value) => toAdditionalPropertySpecification({ name, value }))
-  ) ?? [];
+	sku.variations?.flatMap(({ name, values }) =>
+		values.map((value) => toAdditionalPropertySpecification({ name, value })),
+	) ?? [];
 
 export const toAdditionalPropertySpecification = ({
-  name,
-  value,
-  propertyID,
+	name,
+	value,
+	propertyID,
 }: {
-  name: string;
-  value: string;
-  propertyID?: string;
+	name: string;
+	value: string;
+	propertyID?: string;
 }): PropertyValue => ({
-  "@type": "PropertyValue",
-  name,
-  value,
-  propertyID,
-  valueReference: "SPECIFICATION",
+	"@type": "PropertyValue",
+	name,
+	value,
+	propertyID,
+	valueReference: "SPECIFICATION",
 });
 
 const toAdditionalPropertiesLegacy = (sku: LegacySkuVTEX): PropertyValue[] => {
-  const { variations = [], attachments = [] } = sku;
-
-  const specificationProperties = variations.flatMap((variation) =>
-    sku[variation].map((value) =>
-      toAdditionalPropertySpecification({ name: variation, value })
-    )
-  );
-
-  const attachmentProperties = attachments.map(
-    (attachment) =>
-      ({
-        "@type": "PropertyValue",
-        propertyID: `${attachment.id}`,
-        name: attachment.name,
-        value: attachment.domainValues,
-        required: attachment.required,
-        valueReference: "ATTACHMENT",
-      }) as const,
-  );
-
-  if (attachmentProperties.length === 0) return specificationProperties;
-  specificationProperties.push(...attachmentProperties);
-  return specificationProperties;
+	const { variations = [], attachments = [] } = sku;
+
+	const specificationProperties = variations.flatMap((variation) =>
+		sku[variation].map((value) => toAdditionalPropertySpecification({ name: variation, value })),
+	);
+
+	const attachmentProperties = attachments.map(
+		(attachment) =>
+			({
+				"@type": "PropertyValue",
+				propertyID: `${attachment.id}`,
+				name: attachment.name,
+				value: attachment.domainValues,
+				required: attachment.required,
+				valueReference: "ATTACHMENT",
+			}) as const,
+	);
+
+	if (attachmentProperties.length === 0) return specificationProperties;
+	specificationProperties.push(...attachmentProperties);
+	return specificationProperties;
 };
 
 const buildOffer = (
-  { commertialOffer: offer, sellerId, sellerName, sellerDefault }: SellerVTEX,
-  teasers: Teasers[],
+	{ commertialOffer: offer, sellerId, sellerName, sellerDefault }: SellerVTEX,
+	teasers: Teasers[],
 ): Offer => ({
-  "@type": "Offer",
-  identifier: sellerDefault ? "default" : undefined,
-  price: offer.spotPrice ?? offer.Price,
-  seller: sellerId,
-  sellerName,
-  priceValidUntil: offer.PriceValidUntil,
-  inventoryLevel: { value: offer.AvailableQuantity },
-  giftSkuIds: offer.GiftSkuIds ?? [],
-  teasers,
-  priceSpecification: [
-    {
-      "@type": "UnitPriceSpecification",
-      priceType: SCHEMA_LIST_PRICE,
-      price: offer.ListPrice,
-    },
-    {
-      "@type": "UnitPriceSpecification",
-      priceType: SCHEMA_SALE_PRICE,
-      price: offer.Price,
-    },
-    {
-      "@type": "UnitPriceSpecification",
-      priceType: SCHEMA_SRP,
-      price: offer.PriceWithoutDiscount,
-    },
-    ...offer.Installments.map(
-      (installment): UnitPriceSpecification => ({
-        "@type": "UnitPriceSpecification",
-        priceType: SCHEMA_SALE_PRICE,
-        priceComponentType: SCHEMA_INSTALLMENT,
-        name: installment.PaymentSystemName,
-        description: installment.Name,
-        billingDuration: installment.NumberOfInstallments,
-        billingIncrement: installment.Value,
-        price: installment.TotalValuePlusInterestRate,
-      }),
-    ),
-  ],
-  availability: offer.AvailableQuantity > 0
-    ? SCHEMA_IN_STOCK
-    : SCHEMA_OUT_OF_STOCK,
+	"@type": "Offer",
+	identifier: sellerDefault ? "default" : undefined,
+	price: offer.spotPrice ?? offer.Price,
+	seller: sellerId,
+	sellerName,
+	priceValidUntil: offer.PriceValidUntil,
+	inventoryLevel: { value: offer.AvailableQuantity },
+	giftSkuIds: offer.GiftSkuIds ?? [],
+	teasers,
+	priceSpecification: [
+		{
+			"@type": "UnitPriceSpecification",
+			priceType: SCHEMA_LIST_PRICE,
+			price: offer.ListPrice,
+		},
+		{
+			"@type": "UnitPriceSpecification",
+			priceType: SCHEMA_SALE_PRICE,
+			price: offer.Price,
+		},
+		{
+			"@type": "UnitPriceSpecification",
+			priceType: SCHEMA_SRP,
+			price: offer.PriceWithoutDiscount,
+		},
+		...offer.Installments.map(
+			(installment): UnitPriceSpecification => ({
+				"@type": "UnitPriceSpecification",
+				priceType: SCHEMA_SALE_PRICE,
+				priceComponentType: SCHEMA_INSTALLMENT,
+				name: installment.PaymentSystemName,
+				description: installment.Name,
+				billingDuration: installment.NumberOfInstallments,
+				billingIncrement: installment.Value,
+				price: installment.TotalValuePlusInterestRate,
+			}),
+		),
+	],
+	availability: offer.AvailableQuantity > 0 ? SCHEMA_IN_STOCK : SCHEMA_OUT_OF_STOCK,
 });
 
 const toOffer = (seller: SellerVTEX): Offer =>
-  buildOffer(seller, seller.commertialOffer.teasers ?? []);
+	buildOffer(seller, seller.commertialOffer.teasers ?? []);
 
 const toOfferLegacy = (seller: SellerVTEX): Offer => {
-  const otherTeasers = seller.commertialOffer.DiscountHighLight?.map((i) => {
-    const discount = i as Record<string, string>;
-    const [_k__BackingField, discountName] = Object.entries(discount)?.[0] ??
-      [];
-
-    const teasers: Teasers = {
-      name: discountName,
-      conditions: {
-        minimumQuantity: 0,
-        parameters: [],
-      },
-      effects: {
-        parameters: [],
-      },
-    };
-
-    return teasers;
-  }) ?? [];
-
-  const legacyTeasers = (seller.commertialOffer.Teasers ?? []).map(
-    (teaser) => ({
-      name: teaser["<Name>k__BackingField"],
-      generalValues: teaser["<GeneralValues>k__BackingField"],
-      conditions: {
-        minimumQuantity: teaser["<Conditions>k__BackingField"][
-          "<MinimumQuantity>k__BackingField"
-        ],
-        parameters: teaser["<Conditions>k__BackingField"][
-          "<Parameters>k__BackingField"
-        ].map((parameter) => ({
-          name: parameter["<Name>k__BackingField"],
-          value: parameter["<Value>k__BackingField"],
-        })),
-      },
-      effects: {
-        parameters: teaser["<Effects>k__BackingField"][
-          "<Parameters>k__BackingField"
-        ].map((parameter) => ({
-          name: parameter["<Name>k__BackingField"],
-          value: parameter["<Value>k__BackingField"],
-        })),
-      },
-    }),
-  );
-
-  return buildOffer(seller, [...otherTeasers, ...legacyTeasers]);
+	const otherTeasers =
+		seller.commertialOffer.DiscountHighLight?.map((i) => {
+			const discount = i as Record<string, string>;
+			const [_k__BackingField, discountName] = Object.entries(discount)?.[0] ?? [];
+
+			const teasers: Teasers = {
+				name: discountName,
+				conditions: {
+					minimumQuantity: 0,
+					parameters: [],
+				},
+				effects: {
+					parameters: [],
+				},
+			};
+
+			return teasers;
+		}) ?? [];
+
+	const legacyTeasers = (seller.commertialOffer.Teasers ?? []).map((teaser) => ({
+		name: teaser["<Name>k__BackingField"],
+		generalValues: teaser["<GeneralValues>k__BackingField"],
+		conditions: {
+			minimumQuantity: teaser["<Conditions>k__BackingField"]["<MinimumQuantity>k__BackingField"],
+			parameters: teaser["<Conditions>k__BackingField"]["<Parameters>k__BackingField"].map(
+				(parameter) => ({
+					name: parameter["<Name>k__BackingField"],
+					value: parameter["<Value>k__BackingField"],
+				}),
+			),
+		},
+		effects: {
+			parameters: teaser["<Effects>k__BackingField"]["<Parameters>k__BackingField"].map(
+				(parameter) => ({
+					name: parameter["<Name>k__BackingField"],
+					value: parameter["<Value>k__BackingField"],
+				}),
+			),
+		},
+	}));
+
+	return buildOffer(seller, [...otherTeasers, ...legacyTeasers]);
 };
 
 export const legacyFacetToFilter = (
-  name: string,
-  facets: LegacyFacet[],
-  url: URL,
-  map: string,
-  term: string,
-  behavior: "dynamic" | "static",
-  ignoreCaseSelected?: boolean,
-  fullPath = false,
+	name: string,
+	facets: LegacyFacet[],
+	url: URL,
+	map: string,
+	term: string,
+	behavior: "dynamic" | "static",
+	ignoreCaseSelected?: boolean,
+	fullPath = false,
 ): Filter | null => {
-  const mapSegments = map.split(",").filter((x) => x.length > 0);
-  const pathSegments = term.replace(/^\//, "").split("/").slice(
-    0,
-    mapSegments.length,
-  );
-
-  const mapSet = new Set(
-    mapSegments.map((i) => ignoreCaseSelected ? i.toLowerCase() : i),
-  );
-  const pathSet = new Set(
-    pathSegments.map((i) => ignoreCaseSelected ? i.toLowerCase() : i),
-  );
-
-  // for productClusterIds, we have to use the full path
-  // example:
-  // category2/123?map=c,productClusterIds -> DO NOT WORK
-  // category1/category2/123?map=c,c,productClusterIds -> WORK
-  const hasProductClusterIds = mapSegments.includes("productClusterIds");
-  const hasToBeFullpath = fullPath ||
-    hasProductClusterIds ||
-    mapSegments.includes("ft") ||
-    mapSegments.includes("b");
-
-  const getLink = (facet: LegacyFacet, selected: boolean) => {
-    const index = pathSegments.findIndex((s) => {
-      if (ignoreCaseSelected) {
-        return s.toLowerCase() === facet.Value.toLowerCase();
-      }
-
-      return s === facet.Value;
-    });
-
-    const map = hasToBeFullpath
-      ? facet.Link.split("map=")[1].split(",")
-      : [facet.Map];
-    const value = hasToBeFullpath
-      ? facet.Link.split("?")[0].slice(1).split("/")
-      : [facet.Value];
-
-    const pathSegmentsFiltered = hasProductClusterIds
-      ? [pathSegments[mapSegments.indexOf("productClusterIds")]]
-      : [];
-    const mapSegmentsFiltered = hasProductClusterIds
-      ? ["productClusterIds"]
-      : [];
-
-    const _mapSegments = hasToBeFullpath ? mapSegmentsFiltered : mapSegments;
-    const _pathSegments = hasToBeFullpath ? pathSegmentsFiltered : pathSegments;
-
-    const newMap = selected
-      ? [...mapSegments.filter((_, i) => i !== index)]
-      : [..._mapSegments, ...map];
-    const newPath = selected
-      ? [...pathSegments.filter((_, i) => i !== index)]
-      : [..._pathSegments, ...value];
-
-    // Insertion-sort like algorithm. Uses the c-continuum theorem
-    const zipped: [string, string][] = [];
-    for (let it = 0; it < newMap.length; it++) {
-      let i = 0;
-      while (
-        i < zipped.length && (zipped[i][0] === "c" || zipped[i][0] === "C")
-      ) i++;
-
-      zipped.splice(i, 0, [newMap[it], newPath[it]]);
-    }
-
-    const link = new URL(`/${zipped.map(([, s]) => s).join("/")}`, url);
-    link.searchParams.set("map", zipped.map(([m]) => m).join(","));
-    if (behavior === "static") {
-      link.searchParams.set(
-        "fmap",
-        url.searchParams.get("fmap") || mapSegments.join(","),
-      );
-    }
-    const currentQuery = url.searchParams.get("q");
-    if (currentQuery) {
-      link.searchParams.set("q", currentQuery);
-    }
-
-    return `${link.pathname}${link.search}`;
-  };
-
-  return {
-    "@type": "FilterToggle",
-    quantity: facets?.length,
-    label: name,
-    key: name,
-    values: facets.map((facet) => {
-      const normalizedFacet = name !== "PriceRanges"
-        ? facet
-        : normalizeFacet(facet);
-
-      const selected = mapSet.has(
-        ignoreCaseSelected
-          ? normalizedFacet.Map.toLowerCase()
-          : normalizedFacet.Map,
-      ) &&
-        pathSet.has(
-          ignoreCaseSelected
-            ? normalizedFacet.Value.toLowerCase()
-            : normalizedFacet.Value,
-        );
-
-      return {
-        value: normalizedFacet.Value,
-        quantity: normalizedFacet.Quantity,
-        url: getLink(normalizedFacet, selected),
-        label: normalizedFacet.Name,
-        selected,
-        children: facet.Children?.length > 0
-          ? legacyFacetToFilter(
-            normalizedFacet.Name,
-            facet.Children,
-            url,
-            map,
-            term,
-            behavior,
-            ignoreCaseSelected,
-            fullPath,
-          )
-          : undefined,
-      };
-    }),
-  };
+	const mapSegments = map.split(",").filter((x) => x.length > 0);
+	const pathSegments = term.replace(/^\//, "").split("/").slice(0, mapSegments.length);
+
+	const mapSet = new Set(mapSegments.map((i) => (ignoreCaseSelected ? i.toLowerCase() : i)));
+	const pathSet = new Set(pathSegments.map((i) => (ignoreCaseSelected ? i.toLowerCase() : i)));
+
+	// for productClusterIds, we have to use the full path
+	// example:
+	// category2/123?map=c,productClusterIds -> DO NOT WORK
+	// category1/category2/123?map=c,c,productClusterIds -> WORK
+	const hasProductClusterIds = mapSegments.includes("productClusterIds");
+	const hasToBeFullpath =
+		fullPath || hasProductClusterIds || mapSegments.includes("ft") || mapSegments.includes("b");
+
+	const getLink = (facet: LegacyFacet, selected: boolean) => {
+		const index = pathSegments.findIndex((s) => {
+			if (ignoreCaseSelected) {
+				return s.toLowerCase() === facet.Value.toLowerCase();
+			}
+
+			return s === facet.Value;
+		});
+
+		const map = hasToBeFullpath ? facet.Link.split("map=")[1].split(",") : [facet.Map];
+		const value = hasToBeFullpath ? facet.Link.split("?")[0].slice(1).split("/") : [facet.Value];
+
+		const pathSegmentsFiltered = hasProductClusterIds
+			? [pathSegments[mapSegments.indexOf("productClusterIds")]]
+			: [];
+		const mapSegmentsFiltered = hasProductClusterIds ? ["productClusterIds"] : [];
+
+		const _mapSegments = hasToBeFullpath ? mapSegmentsFiltered : mapSegments;
+		const _pathSegments = hasToBeFullpath ? pathSegmentsFiltered : pathSegments;
+
+		const newMap = selected
+			? [...mapSegments.filter((_, i) => i !== index)]
+			: [..._mapSegments, ...map];
+		const newPath = selected
+			? [...pathSegments.filter((_, i) => i !== index)]
+			: [..._pathSegments, ...value];
+
+		// Insertion-sort like algorithm. Uses the c-continuum theorem
+		const zipped: [string, string][] = [];
+		for (let it = 0; it < newMap.length; it++) {
+			let i = 0;
+			while (i < zipped.length && (zipped[i][0] === "c" || zipped[i][0] === "C")) i++;
+
+			zipped.splice(i, 0, [newMap[it], newPath[it]]);
+		}
+
+		const link = new URL(`/${zipped.map(([, s]) => s).join("/")}`, url);
+		link.searchParams.set("map", zipped.map(([m]) => m).join(","));
+		if (behavior === "static") {
+			link.searchParams.set("fmap", url.searchParams.get("fmap") || mapSegments.join(","));
+		}
+		const currentQuery = url.searchParams.get("q");
+		if (currentQuery) {
+			link.searchParams.set("q", currentQuery);
+		}
+
+		return `${link.pathname}${link.search}`;
+	};
+
+	return {
+		"@type": "FilterToggle",
+		quantity: facets?.length,
+		label: name,
+		key: name,
+		values: facets.map((facet) => {
+			const normalizedFacet = name !== "PriceRanges" ? facet : normalizeFacet(facet);
+
+			const selected =
+				mapSet.has(ignoreCaseSelected ? normalizedFacet.Map.toLowerCase() : normalizedFacet.Map) &&
+				pathSet.has(
+					ignoreCaseSelected ? normalizedFacet.Value.toLowerCase() : normalizedFacet.Value,
+				);
+
+			return {
+				value: normalizedFacet.Value,
+				quantity: normalizedFacet.Quantity,
+				url: getLink(normalizedFacet, selected),
+				label: normalizedFacet.Name,
+				selected,
+				children:
+					facet.Children?.length > 0
+						? legacyFacetToFilter(
+								normalizedFacet.Name,
+								facet.Children,
+								url,
+								map,
+								term,
+								behavior,
+								ignoreCaseSelected,
+								fullPath,
+							)
+						: undefined,
+			};
+		}),
+	};
 };
 
 export const filtersToSearchParams = (
-  selectedFacets: SelectedFacet[],
-  paramsToPersist?: URLSearchParams,
+	selectedFacets: SelectedFacet[],
+	paramsToPersist?: URLSearchParams,
 ) => {
-  const searchParams = new URLSearchParams(paramsToPersist);
+	const searchParams = new URLSearchParams(paramsToPersist);
 
-  for (const { key, value } of selectedFacets) {
-    searchParams.append(`filter.${key}`, value);
-  }
+	for (const { key, value } of selectedFacets) {
+		searchParams.append(`filter.${key}`, value);
+	}
 
-  return searchParams;
+	return searchParams;
 };
 
 const fromLegacyMap: Record<string, string> = {
-  priceFrom: "price",
-  productClusterSearchableIds: "productClusterIds",
+	priceFrom: "price",
+	productClusterSearchableIds: "productClusterIds",
 };
 
 export const legacyFacetsNormalize = (map: string, path: string) => {
-  // Replace legacy price path param to IS price facet format
-  // exemple: de-34,90-a-56,90 turns to 34.90:56.90
-  // may this regex have to be adjusted for international stores
-  const value = path.replace(
-    /de-(?<from>\d+[,]?[\d]+)-a-(?<to>\d+[,]?[\d]+)/,
-    (_match, from, to) => {
-      return `${from.replace(",", ".")}:${to.replace(",", ".")}`;
-    },
-  );
-
-  const key = fromLegacyMap[map] || map;
-
-  return { key, value };
+	// Replace legacy price path param to IS price facet format
+	// exemple: de-34,90-a-56,90 turns to 34.90:56.90
+	// may this regex have to be adjusted for international stores
+	const value = path.replace(
+		/de-(?<from>\d+[,]?[\d]+)-a-(?<to>\d+[,]?[\d]+)/,
+		(_match, from, to) => {
+			return `${from.replace(",", ".")}:${to.replace(",", ".")}`;
+		},
+	);
+
+	const key = fromLegacyMap[map] || map;
+
+	return { key, value };
 };
 
 /**
@@ -952,380 +1041,364 @@ export const legacyFacetsNormalize = (map: string, path: string) => {
  * to Deco and also migrating from VTEX Legacy to VTEX Intelligent Search.
  */
 export const legacyFacetsFromURL = (url: URL) => {
-  const mapSegments = url.searchParams.get("map")?.split(",") ?? [];
-  const pathSegments = url.pathname.split("/").slice(1); // Remove first slash
-  const length = Math.min(mapSegments.length, pathSegments.length);
+	const mapSegments = url.searchParams.get("map")?.split(",") ?? [];
+	const pathSegments = url.pathname.split("/").slice(1); // Remove first slash
+	const length = Math.min(mapSegments.length, pathSegments.length);
 
-  const selectedFacets: SelectedFacet[] = [];
-  for (let it = 0; it < length; it++) {
-    const facet = legacyFacetsNormalize(mapSegments[it], pathSegments[it]);
+	const selectedFacets: SelectedFacet[] = [];
+	for (let it = 0; it < length; it++) {
+		const facet = legacyFacetsNormalize(mapSegments[it], pathSegments[it]);
 
-    selectedFacets.push(facet);
-  }
+		selectedFacets.push(facet);
+	}
 
-  return selectedFacets;
+	return selectedFacets;
 };
 
 export const filtersFromURL = (url: URL) => {
-  const selectedFacets: SelectedFacet[] = legacyFacetsFromURL(url);
+	const selectedFacets: SelectedFacet[] = legacyFacetsFromURL(url);
 
-  url.searchParams.forEach((value, name) => {
-    const [filter, key] = name.split(".");
+	url.searchParams.forEach((value, name) => {
+		const [filter, key] = name.split(".");
 
-    if (filter === "filter" && typeof key === "string") {
-      selectedFacets.push({ key, value });
-    }
-  });
+		if (filter === "filter" && typeof key === "string") {
+			selectedFacets.push({ key, value });
+		}
+	});
 
-  return selectedFacets;
+	return selectedFacets;
 };
 
-export const mergeFacets = (
-  f1: SelectedFacet[],
-  f2: SelectedFacet[],
-): SelectedFacet[] => {
-  const facetKey = (facet: SelectedFacet) =>
-    `key:${facet.key}-value:${facet.value}`;
-  const merged = new Map<string, SelectedFacet>();
-
-  for (const f of f1) {
-    merged.set(facetKey(f), f);
-  }
-  for (const f of f2) {
-    merged.set(facetKey(f), f);
-  }
-
-  return [...merged.values()];
-};
+export const mergeFacets = (f1: SelectedFacet[], f2: SelectedFacet[]): SelectedFacet[] => {
+	const facetKey = (facet: SelectedFacet) => `key:${facet.key}-value:${facet.value}`;
+	const merged = new Map<string, SelectedFacet>();
 
-const isValueRange = (
-  facet: FacetValueRange | FacetValueBoolean,
-): facet is FacetValueRange =>
-  // deno-lint-ignore no-explicit-any
-  Boolean((facet as any).range);
-
-const facetToToggle = (
-  selectedFacets: SelectedFacet[],
-  key: string,
-  paramsToPersist?: URLSearchParams,
-) =>
-(item: FacetValueRange | FacetValueBoolean): FilterToggleValue => {
-  const { quantity, selected } = item;
-  const isRange = isValueRange(item);
-
-  const value = isRange
-    ? formatRange(item.range.from, item.range.to)
-    : item.value;
-  const label = isRange ? value : item.name;
-  const facet = { key, value };
-
-  const filters = selected
-    ? selectedFacets.filter((f) => f.key !== key || f.value !== value)
-    : [...selectedFacets, facet];
-
-  return {
-    value,
-    quantity,
-    selected,
-    url: `?${filtersToSearchParams(filters, paramsToPersist)}`,
-    label,
-  };
+	for (const f of f1) {
+		merged.set(facetKey(f), f);
+	}
+	for (const f of f2) {
+		merged.set(facetKey(f), f);
+	}
+
+	return [...merged.values()];
 };
 
+const isValueRange = (facet: FacetValueRange | FacetValueBoolean): facet is FacetValueRange =>
+	// deno-lint-ignore no-explicit-any
+	Boolean((facet as any).range);
+
+const facetToToggle =
+	(selectedFacets: SelectedFacet[], key: string, paramsToPersist?: URLSearchParams) =>
+	(item: FacetValueRange | FacetValueBoolean): FilterToggleValue => {
+		const { quantity, selected } = item;
+		const isRange = isValueRange(item);
+
+		const value = isRange ? formatRange(item.range.from, item.range.to) : item.value;
+		const label = isRange ? value : item.name;
+		const facet = { key, value };
+
+		const filters = selected
+			? selectedFacets.filter((f) => f.key !== key || f.value !== value)
+			: [...selectedFacets, facet];
+
+		return {
+			value,
+			quantity,
+			selected,
+			url: `?${filtersToSearchParams(filters, paramsToPersist)}`,
+			label,
+		};
+	};
+
 export const toFilter =
-  (selectedFacets: SelectedFacet[], paramsToPersist?: URLSearchParams) =>
-  ({ key, name, quantity, values }: FacetVTEX): Filter => ({
-    "@type": "FilterToggle",
-    key,
-    label: name,
-    quantity: quantity,
-    values: values.map(facetToToggle(selectedFacets, key, paramsToPersist)),
-  });
+	(selectedFacets: SelectedFacet[], paramsToPersist?: URLSearchParams) =>
+	({ key, name, quantity, values }: FacetVTEX): Filter => ({
+		"@type": "FilterToggle",
+		key,
+		label: name,
+		quantity: quantity,
+		values: values.map(facetToToggle(selectedFacets, key, paramsToPersist)),
+	});
 
 function nodeToNavbar(node: Category): SiteNavigationElement {
-  const url = new URL(node.url, "https://example.com");
-
-  return {
-    "@type": "SiteNavigationElement",
-    url: `${url.pathname}${url.search}`,
-    name: node.name,
-    children: node.children.map(nodeToNavbar),
-  };
+	const url = new URL(node.url, "https://example.com");
+
+	return {
+		"@type": "SiteNavigationElement",
+		url: `${url.pathname}${url.search}`,
+		name: node.name,
+		children: node.children.map(nodeToNavbar),
+	};
 }
 
-export const categoryTreeToNavbar = (
-  tree: Category[],
-): SiteNavigationElement[] => tree.map(nodeToNavbar);
+export const categoryTreeToNavbar = (tree: Category[]): SiteNavigationElement[] =>
+	tree.map(nodeToNavbar);
 
 export const toBrand = (
-  { id, name, imageUrl, metaTagDescription }: BrandVTEX,
-  baseUrl: string,
+	{ id, name, imageUrl, metaTagDescription }: BrandVTEX,
+	baseUrl: string,
 ): Brand => ({
-  "@type": "Brand",
-  "@id": `${id}`,
-  name,
-  logo: imageUrl?.startsWith("http") ? imageUrl : `${baseUrl}${imageUrl}`,
-  description: metaTagDescription,
+	"@type": "Brand",
+	"@id": `${id}`,
+	name,
+	logo: imageUrl?.startsWith("http") ? imageUrl : `${baseUrl}${imageUrl}`,
+	description: metaTagDescription,
 });
 
 export const normalizeFacet = (facet: LegacyFacet) => {
-  return {
-    ...facet,
-    Map: "priceFrom",
-    Value: facet.Slug!,
-  };
+	return {
+		...facet,
+		Map: "priceFrom",
+		Value: facet.Slug!,
+	};
 };
 
 export const toReview = (
-  products: Product[],
-  ratings: ProductRating[],
-  reviews: ProductReviewData[],
+	products: Product[],
+	ratings: ProductRating[],
+	reviews: ProductReviewData[],
 ): Product[] => {
-  return products.map((p, index) => {
-    const ratingsCount = ratings[index].totalCount || 0;
-    const productReviews = reviews[index].data || [];
-
-    return {
-      ...p,
-      aggregateRating: {
-        "@type": "AggregateRating",
-        reviewCount: ratingsCount,
-        ratingCount: ratingsCount,
-        ratingValue: ratings[index]?.average || 0,
-      },
-      review: productReviews.map((_, reviewIndex) => ({
-        "@type": "Review",
-        id: productReviews[reviewIndex]?.id?.toString(),
-        author: [{
-          "@type": "Author",
-          name: productReviews[reviewIndex]?.reviewerName,
-          verifiedBuyer: productReviews[reviewIndex]?.verifiedPurchaser,
-        }],
-        itemReviewed: productReviews[reviewIndex]?.productId,
-        datePublished: productReviews[reviewIndex]?.reviewDateTime,
-        reviewHeadline: productReviews[reviewIndex]?.title,
-        reviewBody: productReviews[reviewIndex]?.text,
-        reviewRating: {
-          "@type": "AggregateRating",
-          ratingValue: productReviews[reviewIndex]?.rating || 0,
-        },
-      })),
-    };
-  });
+	return products.map((p, index) => {
+		const ratingsCount = ratings[index].totalCount || 0;
+		const productReviews = reviews[index].data || [];
+
+		return {
+			...p,
+			aggregateRating: {
+				"@type": "AggregateRating",
+				reviewCount: ratingsCount,
+				ratingCount: ratingsCount,
+				ratingValue: ratings[index]?.average || 0,
+			},
+			review: productReviews.map((_, reviewIndex) => ({
+				"@type": "Review",
+				id: productReviews[reviewIndex]?.id?.toString(),
+				author: [
+					{
+						"@type": "Author",
+						name: productReviews[reviewIndex]?.reviewerName,
+						verifiedBuyer: productReviews[reviewIndex]?.verifiedPurchaser,
+					},
+				],
+				itemReviewed: productReviews[reviewIndex]?.productId,
+				datePublished: productReviews[reviewIndex]?.reviewDateTime,
+				reviewHeadline: productReviews[reviewIndex]?.title,
+				reviewBody: productReviews[reviewIndex]?.text,
+				reviewRating: {
+					"@type": "AggregateRating",
+					ratingValue: productReviews[reviewIndex]?.rating || 0,
+				},
+			})),
+		};
+	});
 };
 
 export const toInventories = (
-  products: Product[],
-  inventoriesData: ProductInventoryData[],
+	products: Product[],
+	inventoriesData: ProductInventoryData[],
 ): Product[] => {
-  return products.map((p, index) => {
-    const balance = inventoriesData[index].balance || [];
-
-    const additionalProperty = Array.from(p.additionalProperty || []);
-
-    const inventories: PropertyValue[] = balance.map((b) => ({
-      "@type": "PropertyValue",
-      valueReference: "INVENTORY",
-      propertyID: b.warehouseId,
-      name: b.warehouseName,
-      value: b.totalQuantity?.toString(),
-    }));
-
-    return {
-      ...p,
-      additionalProperty: [...additionalProperty, ...inventories],
-    };
-  });
+	return products.map((p, index) => {
+		const balance = inventoriesData[index].balance || [];
+
+		const additionalProperty = Array.from(p.additionalProperty || []);
+
+		const inventories: PropertyValue[] = balance.map((b) => ({
+			"@type": "PropertyValue",
+			valueReference: "INVENTORY",
+			propertyID: b.warehouseId,
+			name: b.warehouseName,
+			value: b.totalQuantity?.toString(),
+		}));
+
+		return {
+			...p,
+			additionalProperty: [...additionalProperty, ...inventories],
+		};
+	});
 };
 
 type ProductMap = Record<string, Product>;
 
 export const sortProducts = (
-  products: Product[],
-  orderOfIdsOrSkus: string[],
-  prop: "sku" | "inProductGroupWithID",
+	products: Product[],
+	orderOfIdsOrSkus: string[],
+	prop: "sku" | "inProductGroupWithID",
 ) => {
-  const productMap: ProductMap = {};
+	const productMap: ProductMap = {};
 
-  products.forEach((product) => {
-    productMap[product[prop] || product["sku"]] = product;
-  });
+	products.forEach((product) => {
+		productMap[product[prop] || product.sku] = product;
+	});
 
-  return orderOfIdsOrSkus.map((id) => productMap[id]);
+	return orderOfIdsOrSkus.map((id) => productMap[id]);
 };
 
 export const parsePageType = (p: PageTypeVTEX): PageType => {
-  const type = p.pageType;
+	const type = p.pageType;
 
-  // Search or Busca vazia
-  if (type === "FullText") {
-    return "Search";
-  }
+	// Search or Busca vazia
+	if (type === "FullText") {
+		return "Search";
+	}
 
-  // A page that vtex doesn't recognize
-  if (type === "NotFound") {
-    return "Unknown";
-  }
+	// A page that vtex doesn't recognize
+	if (type === "NotFound") {
+		return "Unknown";
+	}
 
-  return type;
+	return type;
 };
 
 function dayOfWeekIndexToString(day?: number): DayOfWeek | undefined {
-  switch (day) {
-    case 0:
-      return "Sunday";
-    case 1:
-      return "Monday";
-    case 2:
-      return "Tuesday";
-    case 3:
-      return "Wednesday";
-    case 4:
-      return "Thursday";
-    case 5:
-      return "Friday";
-    case 6:
-      return "Saturday";
-    default:
-      return undefined;
-  }
+	switch (day) {
+		case 0:
+			return "Sunday";
+		case 1:
+			return "Monday";
+		case 2:
+			return "Tuesday";
+		case 3:
+			return "Wednesday";
+		case 4:
+			return "Thursday";
+		case 5:
+			return "Friday";
+		case 6:
+			return "Saturday";
+		default:
+			return undefined;
+	}
 }
 
 interface Hours {
-  dayOfWeek?: number;
-  openingTime?: string;
-  closingTime?: string;
+	dayOfWeek?: number;
+	openingTime?: string;
+	closingTime?: string;
 }
 
 function toHoursSpecification(hours: Hours): OpeningHoursSpecification {
-  return {
-    "@type": "OpeningHoursSpecification",
-    opens: hours.openingTime,
-    closes: hours.closingTime,
-    dayOfWeek: dayOfWeekIndexToString(hours.dayOfWeek),
-  };
+	return {
+		"@type": "OpeningHoursSpecification",
+		opens: hours.openingTime,
+		closes: hours.closingTime,
+		dayOfWeek: dayOfWeekIndexToString(hours.dayOfWeek),
+	};
 }
 
-function toSpecialHoursSpecification(
-  holiday: PickupHolidays,
-): OpeningHoursSpecification {
-  const dateHoliday = new Date(holiday.date ?? "");
-  // VTEX provide date in ISO format, at 00h on the day
-  const validThrough = dateHoliday.setDate(dateHoliday.getDate() + 1)
-    .toString();
-
-  return {
-    "@type": "OpeningHoursSpecification",
-    opens: holiday.hourBegin,
-    closes: holiday.hourEnd,
-    validFrom: holiday.date,
-    validThrough,
-  };
+function toSpecialHoursSpecification(holiday: PickupHolidays): OpeningHoursSpecification {
+	const dateHoliday = new Date(holiday.date ?? "");
+	// VTEX provide date in ISO format, at 00h on the day
+	const validThrough = dateHoliday.setDate(dateHoliday.getDate() + 1).toString();
+
+	return {
+		"@type": "OpeningHoursSpecification",
+		opens: holiday.hourBegin,
+		closes: holiday.hourEnd,
+		validFrom: holiday.date,
+		validThrough,
+	};
 }
 
 function isPickupPointVCS(
-  pickupPoint: PickupPoint | PickupPointVCS,
+	pickupPoint: PickupPoint | PickupPointVCS,
 ): pickupPoint is PickupPointVCS {
-  return "name" in pickupPoint;
+	return "name" in pickupPoint;
 }
 
 interface ToPlaceOptions {
-  isActive?: boolean;
+	isActive?: boolean;
 }
 
 export function toPlace(
-  pickupPoint: PickupPoint & { distance?: number } | PickupPointVCS,
-  options?: ToPlaceOptions,
+	pickupPoint: (PickupPoint & { distance?: number }) | PickupPointVCS,
+	options?: ToPlaceOptions,
 ): Place {
-  const {
-    name,
-    country,
-    latitude,
-    longitude,
-    openingHoursSpecification,
-    specialOpeningHoursSpecification,
-    isActive,
-  } = isPickupPointVCS(pickupPoint)
-    ? {
-      name: pickupPoint.name,
-      country: pickupPoint.address?.country?.acronym,
-      latitude: pickupPoint.address?.location?.latitude,
-      longitude: pickupPoint.address?.location?.longitude,
-      specialOpeningHoursSpecification: pickupPoint.pickupHolidays?.map(
-        toSpecialHoursSpecification,
-      ),
-      openingHoursSpecification: pickupPoint.businessHours?.map(
-        toHoursSpecification,
-      ),
-      isActive: pickupPoint.isActive,
-    }
-    : {
-      name: pickupPoint.friendlyName,
-      country: pickupPoint.address?.country,
-      latitude: pickupPoint.address?.geoCoordinates?.[0],
-      longitude: pickupPoint.address?.geoCoordinates?.[1],
-      specialOpeningHoursSpecification: pickupPoint.pickupHolidays?.map(
-        toSpecialHoursSpecification,
-      ),
-      openingHoursSpecification: pickupPoint.businessHours?.map((
-        { ClosingTime, DayOfWeek, OpeningTime },
-      ) =>
-        toHoursSpecification({
-          closingTime: ClosingTime,
-          dayOfWeek: DayOfWeek,
-          openingTime: OpeningTime,
-        })
-      ),
-      isActive: options?.isActive,
-    };
-
-  return {
-    "@id": pickupPoint.id,
-    "@type": "Place",
-    address: {
-      "@type": "PostalAddress",
-      addressCountry: country,
-      addressLocality: pickupPoint.address?.city,
-      addressRegion: pickupPoint.address?.state,
-      postalCode: pickupPoint.address?.postalCode,
-      streetAddress: pickupPoint.address?.street,
-    },
-    latitude,
-    longitude,
-    name,
-    specialOpeningHoursSpecification,
-    openingHoursSpecification,
-    additionalProperty: [
-      {
-        "@type": "PropertyValue",
-        name: "distance",
-        value: `${pickupPoint.distance}`,
-      },
-      {
-        "@type": "PropertyValue",
-        name: "isActive",
-        value: typeof isActive === "boolean" ? `${isActive}` : undefined,
-      },
-    ],
-  };
+	const {
+		name,
+		country,
+		latitude,
+		longitude,
+		openingHoursSpecification,
+		specialOpeningHoursSpecification,
+		isActive,
+	} = isPickupPointVCS(pickupPoint)
+		? {
+				name: pickupPoint.name,
+				country: pickupPoint.address?.country?.acronym,
+				latitude: pickupPoint.address?.location?.latitude,
+				longitude: pickupPoint.address?.location?.longitude,
+				specialOpeningHoursSpecification: pickupPoint.pickupHolidays?.map(
+					toSpecialHoursSpecification,
+				),
+				openingHoursSpecification: pickupPoint.businessHours?.map(toHoursSpecification),
+				isActive: pickupPoint.isActive,
+			}
+		: {
+				name: pickupPoint.friendlyName,
+				country: pickupPoint.address?.country,
+				latitude: pickupPoint.address?.geoCoordinates?.[0],
+				longitude: pickupPoint.address?.geoCoordinates?.[1],
+				specialOpeningHoursSpecification: pickupPoint.pickupHolidays?.map(
+					toSpecialHoursSpecification,
+				),
+				openingHoursSpecification: pickupPoint.businessHours?.map(
+					({ ClosingTime, DayOfWeek, OpeningTime }) =>
+						toHoursSpecification({
+							closingTime: ClosingTime,
+							dayOfWeek: DayOfWeek,
+							openingTime: OpeningTime,
+						}),
+				),
+				isActive: options?.isActive,
+			};
+
+	return {
+		"@id": pickupPoint.id,
+		"@type": "Place",
+		address: {
+			"@type": "PostalAddress",
+			addressCountry: country,
+			addressLocality: pickupPoint.address?.city,
+			addressRegion: pickupPoint.address?.state,
+			postalCode: pickupPoint.address?.postalCode,
+			streetAddress: pickupPoint.address?.street,
+		},
+		latitude,
+		longitude,
+		name,
+		specialOpeningHoursSpecification,
+		openingHoursSpecification,
+		additionalProperty: [
+			{
+				"@type": "PropertyValue",
+				name: "distance",
+				value: `${pickupPoint.distance}`,
+			},
+			{
+				"@type": "PropertyValue",
+				name: "isActive",
+				value: typeof isActive === "boolean" ? `${isActive}` : undefined,
+			},
+		],
+	};
 }
 
 export const toPostalAddress = (address: Address): PostalAddress => {
-  return {
-    "@type": "PostalAddress",
-    "@id": address.addressId,
-    addressCountry: address.country,
-    addressLocality: address.city,
-    addressRegion: address.state,
-    areaServed: address.neighborhood || undefined,
-    postalCode: address.postalCode,
-    streetAddress: address.street,
-    identifier: address.number || undefined,
-    name: address.addressName || undefined,
-    alternateName: address.receiverName || undefined,
-    description: address.complement || undefined,
-    disambiguatingDescription: address.reference || undefined,
-    latitude: address.geoCoordinates?.[0] || undefined,
-    longitude: address.geoCoordinates?.[1] || undefined,
-  };
+	return {
+		"@type": "PostalAddress",
+		"@id": address.addressId,
+		addressCountry: address.country,
+		addressLocality: address.city,
+		addressRegion: address.state,
+		areaServed: address.neighborhood || undefined,
+		postalCode: address.postalCode,
+		streetAddress: address.street,
+		identifier: address.number || undefined,
+		name: address.addressName || undefined,
+		alternateName: address.receiverName || undefined,
+		description: address.complement || undefined,
+		disambiguatingDescription: address.reference || undefined,
+		latitude: address.geoCoordinates?.[0] || undefined,
+		longitude: address.geoCoordinates?.[1] || undefined,
+	};
 };