@decocms/apps-commerce 7.2.0

package/src/sdk/url.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from "vitest";
+import { relative } from "./url";
+
+describe("relative()", () => {
+	describe("base behaviour (no options)", () => {
+		it("returns undefined for undefined input", () => {
+			expect(relative(undefined)).toBeUndefined();
+		});
+
+		it("returns undefined for empty string input", () => {
+			expect(relative("")).toBeUndefined();
+		});
+
+		it("preserves a relative path-only URL", () => {
+			expect(relative("/p/foo")).toBe("/p/foo");
+		});
+
+		it("preserves a relative path with search params", () => {
+			expect(relative("/p/foo?a=1&b=2")).toBe("/p/foo?a=1&b=2");
+		});
+
+		it("strips the origin from an absolute URL", () => {
+			expect(relative("https://x.example.com/p/foo?a=1")).toBe("/p/foo?a=1");
+		});
+
+		it("returns the original string when URL parsing fails", () => {
+			// `new URL` against the `https://localhost` base accepts almost
+			// anything string-shaped, so genuine throws are rare. The catch
+			// branch exists as a defence against non-string-like values
+			// reaching the helper through type-erased call sites — we
+			// exercise it by forcing a non-string through the public API.
+			const malformed = {
+				toString() {
+					throw new Error("boom");
+				},
+			} as unknown as string;
+			expect(relative(malformed)).toBe(malformed);
+		});
+	});
+
+	describe("stripSearchParams", () => {
+		it("removes the listed key", () => {
+			expect(
+				relative("/p/foo?idsku=1&keep=2", {
+					stripSearchParams: ["idsku"],
+				}),
+			).toBe("/p/foo?keep=2");
+		});
+
+		it("removes multiple listed keys", () => {
+			expect(
+				relative("/p/foo?idsku=1&skuId=2&keep=3", {
+					stripSearchParams: ["idsku", "skuId"],
+				}),
+			).toBe("/p/foo?keep=3");
+		});
+
+		it("drops the trailing ? when ALL params are stripped", () => {
+			expect(
+				relative("/p/foo?idsku=1&skuId=2", {
+					stripSearchParams: ["idsku", "skuId"],
+				}),
+			).toBe("/p/foo");
+		});
+
+		it("is a no-op when stripSearchParams is empty", () => {
+			expect(relative("/p/foo?a=1", { stripSearchParams: [] })).toBe("/p/foo?a=1");
+		});
+
+		it("is a no-op when stripSearchParams is undefined (option object only)", () => {
+			expect(relative("/p/foo?a=1", {})).toBe("/p/foo?a=1");
+		});
+
+		it("silently ignores keys that are not present in the URL", () => {
+			expect(
+				relative("/p/foo?keep=1", {
+					stripSearchParams: ["idsku", "skuId"],
+				}),
+			).toBe("/p/foo?keep=1");
+		});
+
+		it("strips keys from absolute URLs while still removing the origin", () => {
+			expect(
+				relative("https://x.example.com/p/foo?idsku=1&keep=2", {
+					stripSearchParams: ["idsku"],
+				}),
+			).toBe("/p/foo?keep=2");
+		});
+
+		it("preserves repeated keys for params not in the strip list", () => {
+			// URLSearchParams keeps repeats; relative() must not collapse them.
+			expect(
+				relative("/p/foo?tag=a&tag=b&idsku=1", {
+					stripSearchParams: ["idsku"],
+				}),
+			).toBe("/p/foo?tag=a&tag=b");
+		});
+
+		it("removes ALL occurrences of a repeated key when listed", () => {
+			expect(
+				relative("/p/foo?idsku=1&idsku=2&keep=3", {
+					stripSearchParams: ["idsku"],
+				}),
+			).toBe("/p/foo?keep=3");
+		});
+	});
+
+	describe("backwards compatibility with the 1-arg signature", () => {
+		it("matches the pre-options behaviour byte-for-byte for relative paths", () => {
+			expect(relative("/p/foo?a=1")).toBe("/p/foo?a=1");
+		});
+
+		it("matches the pre-options behaviour byte-for-byte for absolute URLs", () => {
+			expect(relative("https://x.example.com/path?q=1")).toBe("/path?q=1");
+		});
+
+		it('preserves the previous "://path-style" passthrough behaviour', () => {
+			// The original 9-line apps `relative()` parsed this against
+			// the localhost base too — both old and new implementations
+			// return "/://no-scheme". This assertion locks in the byte-
+			// for-byte identical behaviour for the no-options case.
+			expect(relative("://no-scheme")).toBe("/://no-scheme");
+		});
+	});
+});

package/src/sdk/url.ts

@@ -0,0 +1,52 @@
+/**
+ * Options for {@link relative}.
+ *
+ * `stripSearchParams` is the primitive escape hatch used by sites that
+ * need to drop platform-specific query keys (commonly VTEX's `idsku`
+ * / `skuId`) before linking to a PDP. Any keys not listed are kept.
+ *
+ * Sites previously hand-rolled this by forking `relative()` locally
+ * with a `removeIdSku?: boolean` flag — see the migration guide and
+ * the `local-framework-duplicate` audit rule in `@decocms/start`.
+ */
+export interface RelativeOptions {
+	stripSearchParams?: string[];
+}
+
+/**
+ * Convert an absolute or relative URL string into a path + search
+ * fragment safe to feed into `<Link to={…} />` or `<a href={…}>`.
+ *
+ * - Returns `undefined` when `link` is falsy (the empty / undefined
+ *   case is the common "no permalink yet" branch in product cards).
+ * - Returns the original string when URL parsing fails — preserves
+ *   pre-existing behaviour for malformed inputs.
+ * - When `options.stripSearchParams` is non-empty, every listed key
+ *   is removed from the resulting `?...` portion. Keys not present
+ *   in the input are silently ignored. The pathname is never
+ *   touched — only search params.
+ *
+ * @example
+ *   relative("/p/foo");                                        // "/p/foo"
+ *   relative("https://x.com/p/foo?a=1");                       // "/p/foo?a=1"
+ *   relative("/p/foo?idsku=1&keep=2", {
+ *     stripSearchParams: ["idsku"],
+ *   });                                                         // "/p/foo?keep=2"
+ *   relative(undefined);                                        // undefined
+ */
+export function relative(link?: string, options?: RelativeOptions): string | undefined {
+	if (!link) return undefined;
+	try {
+		const linkUrl = new URL(link, "https://localhost");
+		const stripKeys = options?.stripSearchParams;
+		if (stripKeys && stripKeys.length > 0) {
+			for (const key of stripKeys) {
+				linkUrl.searchParams.delete(key);
+			}
+		}
+		const search = linkUrl.searchParams.toString();
+		return `${linkUrl.pathname}${search ? `?${search}` : ""}`;
+	} catch {
+		return link;
+	}
+}

package/src/sdk/useOffer.ts

@@ -0,0 +1,64 @@
+import type { AggregateOffer, UnitPriceSpecification } from "../types/commerce";
+
+const bestInstallment = (acc: UnitPriceSpecification | null, curr: UnitPriceSpecification) => {
+	if (curr.priceComponentType !== "https://schema.org/Installment") {
+		return acc;
+	}
+
+	if (!acc) {
+		return curr;
+	}
+
+	if (acc.price > curr.price) {
+		return curr;
+	}
+
+	if (acc.price < curr.price) {
+		return acc;
+	}
+
+	if (acc.billingDuration && curr.billingDuration && acc.billingDuration < curr.billingDuration) {
+		return curr;
+	}
+
+	return acc;
+};
+
+const installmentToString = (
+	installment: UnitPriceSpecification,
+	locale = "pt-BR",
+	currency = "BRL",
+) => {
+	const { billingDuration, billingIncrement } = installment;
+
+	if (!billingDuration || !billingIncrement) {
+		return "";
+	}
+
+	const formatted = new Intl.NumberFormat(locale, {
+		style: "currency",
+		currency,
+	}).format(billingIncrement);
+
+	return `${billingDuration}x ${formatted}`;
+};
+
+export const useOffer = (aggregateOffer?: AggregateOffer) => {
+	const offer = aggregateOffer?.offers?.[0];
+	const listPrice = offer?.priceSpecification?.find(
+		(spec) => spec.priceType === "https://schema.org/ListPrice",
+	);
+	const installment = offer?.priceSpecification?.reduce(bestInstallment, null);
+	const seller = offer?.seller;
+	const price = offer?.price;
+	const availability = offer?.availability;
+
+	return {
+		price,
+		listPrice: listPrice?.price,
+		availability,
+		seller,
+		installments: installment && price ? installmentToString(installment) : null,
+		installment,
+	};
+};

package/src/sdk/useVariantPossibilities.ts

@@ -0,0 +1,43 @@
+import type { ProductLeaf, PropertyValue } from "../types/commerce";
+
+export type Possibilities = Record<string, Record<string, string | undefined>>;
+
+const hash = ({ name, value }: PropertyValue) => `${name}::${value}`;
+
+const omit = new Set(["category", "cluster", "RefId", "descriptionHtml"]);
+
+export const useVariantPossibilities = (
+	variants: ProductLeaf[],
+	selected: ProductLeaf,
+): Possibilities => {
+	const possibilities: Possibilities = {};
+	const selectedSpecs = new Set(selected.additionalProperty?.map(hash));
+
+	for (const variant of variants) {
+		const { url, additionalProperty = [], productID } = variant;
+		const isSelected = productID === selected.productID;
+		const specs = additionalProperty.filter(({ name }) => !omit.has(name!));
+
+		for (let it = 0; it < specs.length; it++) {
+			const name = specs[it].name!;
+			const value = specs[it].value!;
+
+			if (omit.has(name)) continue;
+
+			if (!possibilities[name]) {
+				possibilities[name] = {};
+			}
+
+			const isSelectable =
+				it === 0 || specs.every((s) => s.name === name || selectedSpecs.has(hash(s)));
+
+			possibilities[name][value] = isSelected
+				? url
+				: isSelectable
+					? possibilities[name][value] || url
+					: possibilities[name][value];
+		}
+	}
+
+	return possibilities;
+};