@cartbase/storefront 0.8.0 → 0.10.0

package/src/order/order-totals.tsx

@@ -1,4 +1,4 @@
-import { DualPrice } from "../lib/dual-price"
+import { Price } from "../lib/price"
 import { findFeeLine, type LineLike } from "../lib/cart-helpers"
 import { defaultOrderLabels, type OrderLabels } from "./labels"
 
@@ -217,14 +217,14 @@ export function OrderTotals({
             ) : row.negative ? (
               <span className="text-sm text-success">
                 -{" "}
-                <DualPrice
+                <Price
                   amount={row.amount}
                   currencyCode={currencyCode}
                   className="text-sm text-success"
                 />
               </span>
             ) : (
-              <DualPrice
+              <Price
                 amount={row.amount}
                 currencyCode={currencyCode}
                 className="text-sm text-foreground"
@@ -237,7 +237,7 @@ export function OrderTotals({
       <div className="h-px bg-border my-3" />
       <div className="flex justify-between items-baseline">
         <span className="text-[15px] font-bold text-foreground">{l.total}</span>
-        <DualPrice
+        <Price
           amount={total}
           currencyCode={currencyCode}
           className="text-xl font-bold text-foreground tracking-tight"

package/src/products/index.ts

@@ -5,7 +5,6 @@
  */
 export { ProductLabelsProvider, useProductLabels } from "./context"
 export { defaultProductLabels, type ProductLabels } from "./labels"
-export { bulgarianProductLabels } from "./labels-bg"
 
 export {
   optionsAsKeymap,

package/src/reviews-ui/index.ts

@@ -10,7 +10,6 @@ export {
   defaultReviewsUiLabels,
   type ReviewsUiLabels,
 } from "./labels"
-export { bulgarianReviewsUiLabels } from "./labels-bg"
 
 export {
   formatLabel,

package/src/store/index.ts

@@ -8,7 +8,6 @@ export {
   sortOptionLabelKeys,
   type StoreLabels,
 } from "./labels"
-export { bulgarianStoreLabels } from "./labels-bg"
 
 export { Pagination } from "./pagination"
 export { SortSelect, type SortSelectProps } from "./sort-select"

package/src/tracking/attribution.ts

@@ -496,6 +496,16 @@ const TTCLID_COOKIE = "_1c_ttclid"
 const GCLID_COOKIE = "_1c_gclid"
 const GBRAID_COOKIE = "_1c_gbraid"
 const WBRAID_COOKIE = "_1c_wbraid"
+/**
+ * OpenAI's click id, from `oppref` on the landing URL.
+ *
+ * Their own SDK stores the same parameter in a first-party `__oppref`
+ * cookie at init, and we capture it here anyway: the Conversions API takes
+ * `oppref` on the server event explicitly, and this module runs on the
+ * landing page whether or not their script loaded or was consented to. Ours
+ * is the one the server reads.
+ */
+const OPPREF_COOKIE = "_1c_oppref"
 
 /** TikTok's ttclid lifetime follows the CTA window in Attribution
  *  Manager; Google's conversion window tops out at 90 days. One TTL
@@ -509,6 +519,7 @@ const CLICK_ID_CAPTURE: ReadonlyArray<readonly [string, string]> = [
   [GCLID_COOKIE, "gclid"],
   [GBRAID_COOKIE, "gbraid"],
   [WBRAID_COOKIE, "wbraid"],
+  [OPPREF_COOKIE, "oppref"],
 ]
 
 /**
@@ -522,6 +533,7 @@ export const CLICK_ID_COOKIES = {
   gbraid: GBRAID_COOKIE,
   wbraid: WBRAID_COOKIE,
   ttp: "_ttp",
+  oppref: OPPREF_COOKIE,
 } as const
 
 /** cookie name → order.metadata key (code truth for the server side:
@@ -532,6 +544,7 @@ export const CLICK_ID_METADATA_KEYS: ReadonlyArray<readonly [string, string]> =
   [CLICK_ID_COOKIES.gclid, "google_gclid"],
   [CLICK_ID_COOKIES.gbraid, "google_gbraid"],
   [CLICK_ID_COOKIES.wbraid, "google_wbraid"],
+  [CLICK_ID_COOKIES.oppref, "oai_oppref"],
 ]
 
 /**

package/src/tracking/chatgpt-pixel.tsx

@@ -0,0 +1,92 @@
+"use client"
+
+import Script from "next/script"
+
+import { CONSENT_COOKIE } from "./consent"
+import { jsStringLiteral } from "./inline-script"
+
+/**
+ * ChatGptPixel — the OpenAI measurement pixel, the ChatGPT Ads twin of
+ * <MetaPixel> and <TikTokPixel>.
+ *
+ * The loader is OpenAI's own, verbatim from
+ * https://developers.openai.com/ads/measurement-pixel: a command queue on
+ * `window.oaiq` that buffers calls until the SDK arrives from
+ * bzrcdn.openai.com, injected with `<Script strategy="afterInteractive">`.
+ *
+ * CONSENT IS CLOSED BEFORE INIT, and that order is the whole point. Their
+ * consent default is TRUE, so an unconsented visitor is measured unless we
+ * say otherwise first:
+ *
+ *     oaiq("consent", false)   // queued BEFORE init — no pings
+ *     oaiq("init", { pixelId })
+ *     oaiq("consent", true)    // only once the visitor accepted
+ *
+ * The script is LOADED either way, like the Meta and TikTok gates beside
+ * it, so a later grant costs no round trip. But the page view is fired
+ * only AFTER a grant, and that is deliberate rather than cautious: their
+ * docs state that with consent false the pixel sends no measurement
+ * pings, and they do NOT document whether a call made while consent was
+ * false is released on a later grant. TikTok documents exactly that
+ * (`holdConsent` queues, `grantConsent` flushes) and our TikTok gate
+ * relies on it. Nothing here relies on behaviour OpenAI has not written
+ * down: an unconsented page view is not sent, and not counted on later.
+ *
+ * The decision is read from the shared `_1c_consent` cookie inside the
+ * snippet, before anything can be sent, and live changes arrive through
+ * `applyConsent()` in ./consent.ts — there is no cookie watcher.
+ *
+ * The page view is ours to fire at all: their pixel sends nothing at init,
+ * unlike Meta's and TikTok's base code.
+ *
+ * Their SDK also captures `oppref` off the landing URL into a first-party
+ * `__oppref` cookie by itself. Our attribution module captures the same
+ * parameter into `_1c_oppref` independently, so the server-side
+ * Conversions API event can carry the click even on a visit where this
+ * script never loaded at all.
+ *
+ * Renders nothing when `pixelId` is falsy, so a layout can mount it
+ * unconditionally.
+ */
+export function ChatGptPixel({ pixelId }: { pixelId?: string }) {
+  if (!pixelId) return null
+
+  const id = jsStringLiteral(pixelId)
+
+  const initSnippet = `
+(function (w, d, s, u) {
+  if (w.oaiq) return;
+  var q = function () { q.q.push(arguments); };
+  q.q = [];
+  w.oaiq = q;
+  var js = d.createElement(s);
+  js.async = true;
+  js.src = u;
+  var f = d.getElementsByTagName(s)[0];
+  f.parentNode.insertBefore(js, f);
+})(window, document, "script", "https://bzrcdn.openai.com/sdk/oaiq.min.js");
+
+oaiq("consent", false);
+oaiq("init", { pixelId: ${id} });
+
+(function (d) {
+  var ads = false;
+  try {
+    var m = d.cookie.match(/(?:^|; )${CONSENT_COOKIE}=([^;]*)/);
+    if (m) { ads = !!JSON.parse(decodeURIComponent(m[1])).ads; }
+  } catch (e) {}
+  if (ads) {
+    oaiq("consent", true);
+    oaiq("measure", "page_viewed", { type: "contents" });
+  }
+})(document);
+`.trim()
+
+  return (
+    <Script
+      id="chatgpt-pixel-init"
+      strategy="afterInteractive"
+      dangerouslySetInnerHTML={{ __html: initSnippet }}
+    />
+  )
+}

package/src/tracking/consent-banner.tsx

@@ -341,7 +341,11 @@ function ConsentRow({
  * its settings layer ("withdraw consent as easily as it was given").
  */
 export function ConsentSettingsLink({
-  children = "Настройки на бисквитките",
+  // English, like every other default in the library. It shipped as
+  // "Настройки на бисквитките" until 2026-09-13, which put Bulgarian in
+  // the footer of every store that mounted this link. Pass children to
+  // translate it; the consent banner has no label pack of its own.
+  children = "Cookie settings",
   className,
 }: {
   children?: React.ReactNode

package/src/tracking/consent.ts

@@ -131,6 +131,18 @@ export function applyConsent(choices: ConsentChoices): void {
     if (choices.ads) w.ttq.grantConsent()
     else w.ttq.revokeConsent()
   }
+
+  // ChatGPT Ads. One command on their own queue, `oaiq("consent", bool)`,
+  // which works before the SDK has arrived because the queue buffers it.
+  //
+  // A grant also fires the page view the loader withheld: their docs say
+  // an unconsented event sends no ping and do not promise that a held call
+  // is released later, so the visitor who accepts on their third page is
+  // counted from the grant onward rather than not at all.
+  if (typeof w.oaiq === "function") {
+    w.oaiq("consent", choices.ads)
+    if (choices.ads) w.oaiq("measure", "page_viewed", { type: "contents" })
+  }
 }
 
 /**

package/src/tracking/events.ts

@@ -24,6 +24,14 @@ import {
   trackTikTokPurchase,
   trackTikTokViewContent,
 } from "./ttq"
+import {
+  minorUnits,
+  trackOpenAiCheckoutStarted,
+  trackOpenAiContentsViewed,
+  trackOpenAiItemsAdded,
+  trackOpenAiOrderCreated,
+  type OpenAiContentItem,
+} from "./oaiq"
 import { googleAdsPurchaseSendTo, trackGoogleAdsPurchase } from "./google-ads"
 import type { TrackingConfig } from "./types"
 
@@ -118,6 +126,25 @@ const tiktokContents = (lines: TrackedLine[]) =>
 const unitCount = (lines: TrackedLine[]) =>
   lines.reduce((sum, line) => sum + (Number(line.quantity) || 0), 0)
 
+/**
+ * ChatGPT Ads contents. The shape is close to TikTok's, but every amount
+ * is an INTEGER IN MINOR UNITS on this vendor, which is why the mapping
+ * cannot be shared with `tiktokContents` above: the same numbers in the
+ * same field names would be a hundredfold under-report.
+ */
+const openAiContents = (
+  lines: TrackedLine[],
+  currency: string
+): OpenAiContentItem[] =>
+  lines.map((line) => ({
+    id: line.productId,
+    name: line.title,
+    content_type: "product",
+    quantity: line.quantity,
+    amount: minorUnits(line.price),
+    currency,
+  }))
+
 /** Product page view. */
 export function trackProductView(input: {
   line: TrackedLine
@@ -137,6 +164,12 @@ export function trackProductView(input: {
     currency,
     value,
   })
+  trackOpenAiContentsViewed({
+    contentId: line.productId,
+    contentName: line.title,
+    currency,
+    value,
+  })
   trackGAViewItem({ currency, value, items: gaItems([line], currency) })
   trackRybbitViewItem({
     item_id: line.variantId || line.productId,
@@ -168,6 +201,14 @@ export function trackCartAdd(input: {
     currency,
     value,
   })
+  trackOpenAiItemsAdded({
+    contentId: line.productId,
+    contentName: line.title,
+    quantity: line.quantity,
+    price: line.price,
+    currency,
+    value,
+  })
   trackGAAddToCart({ currency, value, items: gaItems([line], currency) })
   trackRybbitAddToCart({
     item_id: line.variantId || line.productId,
@@ -199,6 +240,11 @@ export function trackCheckoutStart(input: {
     currency,
     value,
   })
+  trackOpenAiCheckoutStarted({
+    contents: openAiContents(lines, currency),
+    currency,
+    value,
+  })
   trackGABeginCheckout({
     currency,
     value,
@@ -222,8 +268,9 @@ export function trackCheckoutStart(input: {
  * malformed `send_to` is accepted by Google and silently dropped.
  *
  * Everything here is deduped against the server: Meta on
- * `purchase_<displayId>`, TikTok on `tt_purchase_<displayId>`, GA4 and
- * Google Ads on the transaction id, which is `displayId` itself.
+ * `purchase_<displayId>`, TikTok on `tt_purchase_<displayId>`, ChatGPT Ads
+ * on `oai_order_<displayId>`, GA4 and Google Ads on the transaction id,
+ * which is `displayId` itself.
  */
 export function trackOrderPurchase(
   order: TrackedOrder,
@@ -261,6 +308,13 @@ export function trackOrderPurchase(
     customerType,
   })
 
+  trackOpenAiOrderCreated({
+    contents: openAiContents(lines, currency),
+    currency,
+    value,
+    displayId,
+  })
+
   trackGAPurchase({
     transaction_id: transactionId,
     currency,

package/src/tracking/index.ts

@@ -57,6 +57,7 @@ export { MetaPixel, updatePixelAdvancedMatching } from "./meta-pixel"
 export { GA4, GoogleTag } from "./ga4"
 export { Gtm } from "./gtm"
 export { TikTokPixel } from "./tiktok-pixel"
+export { ChatGptPixel } from "./chatgpt-pixel"
 export { StorefrontTags } from "./storefront-tags"
 export { TrackInit } from "./track-init"
 // The live-visitor heartbeat. Mounted by <StorefrontTags> so a storefront
@@ -134,6 +135,17 @@ export {
   tiktokPurchaseEventId,
   type TikTokContentItem,
 } from "./ttq"
+export {
+  trackOpenAiPageView,
+  trackOpenAiContentsViewed,
+  trackOpenAiItemsAdded,
+  trackOpenAiCheckoutStarted,
+  trackOpenAiOrderCreated,
+  applyOpenAiConsent,
+  openAiOrderEventId,
+  minorUnits,
+  type OpenAiContentItem,
+} from "./oaiq"
 export {
   trackGoogleAdsPurchase,
   googleAdsPurchaseSendTo,

package/src/tracking/oaiq.ts

@@ -0,0 +1,206 @@
+"use client"
+
+/**
+ * Typed wrappers around the global `oaiq` command queue from the OpenAI
+ * measurement pixel — the ChatGPT Ads twin of ./ttq.ts and ./fbq.ts, and
+ * deliberately the same shape so a surface that fires one can fire the
+ * other on the line below.
+ *
+ * Every helper no-ops when `window.oaiq` is absent (pixel not configured,
+ * server render, script blocked), so callers need no guards.
+ *
+ * The call signature is theirs, from
+ * https://developers.openai.com/ads/measurement-pixel:
+ *
+ *     oaiq("measure", eventName, eventData, { event_id })
+ *
+ * Two things here are NOT like the other vendors, and both are silent when
+ * wrong:
+ *
+ *   1. MONEY IS AN INTEGER IN MINOR UNITS. Meta, TikTok and GA4 all read
+ *      `value: 25.99`; OpenAI reads `amount: 2599`. Passing a decimal
+ *      under-reports revenue by a factor of a hundred with nothing to show
+ *      for it, so every amount goes through `minorUnits` below and no
+ *      caller passes `amount` itself.
+ *   2. EVENT DATA CARRIES ITS OWN `type`. Each event name is bound to one
+ *      of four data shapes; the five commerce events we fire all take
+ *      `contents`, so the wrappers set it and callers cannot get it wrong.
+ *
+ * Event names are theirs and are not interchangeable with Meta's or
+ * TikTok's: `contents_viewed`, `items_added`, `checkout_started`,
+ * `order_created`, `page_viewed`.
+ */
+
+/** One product line inside `contents`. */
+export type OpenAiContentItem = {
+  id: string
+  name?: string
+  content_type?: string
+  quantity?: number
+  /** Integer, minor units. */
+  amount?: number
+  currency?: string
+}
+
+type OpenAiEventData = {
+  type: "contents"
+  /** Integer, minor units. */
+  amount?: number
+  currency?: string
+  contents?: OpenAiContentItem[]
+}
+
+type OaiqFn = (
+  command: "init" | "measure" | "consent",
+  ...args: unknown[]
+) => void
+
+function safeOaiq(): OaiqFn | null {
+  if (typeof window === "undefined") return null
+  const oaiq = (window as unknown as { oaiq?: OaiqFn }).oaiq
+  return typeof oaiq === "function" ? oaiq : null
+}
+
+/**
+ * Major units to their integer minor units: 25.99 becomes 2599.
+ *
+ * The twin of `openAiMinorUnits` in the platform's
+ * src/lib/tracking/constants.ts. Duplicated rather than imported because
+ * this package cannot reach into the platform, and rounded rather than
+ * truncated because 0.1 + 0.2 is 0.30000000000000004 in binary floating
+ * point and truncation would report 29 cents for 30.
+ */
+export function minorUnits(amountInMajorUnits: number): number {
+  return Math.round((Number(amountInMajorUnits) || 0) * 100)
+}
+
+/**
+ * THE order dedup key — must equal what the backend forwarder sends
+ * (`openAiOrderEventId` in the platform's src/lib/tracking/constants.ts).
+ * Built from display_id here so the format cannot drift between the two
+ * sides, the same guarantee `trackPurchase` gives for Meta and
+ * `tiktokPurchaseEventId` for TikTok.
+ *
+ * OpenAI deduplicates on pixel id + event name + id, keeping the FIRST
+ * event it receives, so the browser and the server collapse into one
+ * conversion whichever arrives first.
+ */
+export function openAiOrderEventId(displayId: string | number): string {
+  return `oai_order_${displayId}`
+}
+
+/** A page view. Their pixel fires nothing on its own at init. */
+export function trackOpenAiPageView(): void {
+  const oaiq = safeOaiq()
+  if (!oaiq) return
+  oaiq("measure", "page_viewed", { type: "contents" } satisfies OpenAiEventData)
+}
+
+export function trackOpenAiContentsViewed(data: {
+  contentId: string
+  contentName?: string
+  currency: string
+  /** Major units — converted here. */
+  value: number
+}): void {
+  const oaiq = safeOaiq()
+  if (!oaiq) return
+  oaiq("measure", "contents_viewed", {
+    type: "contents",
+    amount: minorUnits(data.value),
+    currency: data.currency,
+    contents: [
+      {
+        id: data.contentId,
+        name: data.contentName,
+        content_type: "product",
+        quantity: 1,
+      },
+    ],
+  } satisfies OpenAiEventData)
+}
+
+export function trackOpenAiItemsAdded(data: {
+  contentId: string
+  contentName?: string
+  quantity: number
+  /** Unit price, major units. */
+  price: number
+  currency: string
+  /** Line value, major units. */
+  value: number
+}): void {
+  const oaiq = safeOaiq()
+  if (!oaiq) return
+  oaiq("measure", "items_added", {
+    type: "contents",
+    amount: minorUnits(data.value),
+    currency: data.currency,
+    contents: [
+      {
+        id: data.contentId,
+        name: data.contentName,
+        content_type: "product",
+        quantity: data.quantity,
+        amount: minorUnits(data.price),
+        currency: data.currency,
+      },
+    ],
+  } satisfies OpenAiEventData)
+}
+
+export function trackOpenAiCheckoutStarted(data: {
+  contents: OpenAiContentItem[]
+  currency: string
+  /** Cart value, major units. */
+  value: number
+}): void {
+  const oaiq = safeOaiq()
+  if (!oaiq) return
+  oaiq("measure", "checkout_started", {
+    type: "contents",
+    amount: minorUnits(data.value),
+    currency: data.currency,
+    contents: data.contents,
+  } satisfies OpenAiEventData)
+}
+
+export function trackOpenAiOrderCreated(data: {
+  contents: OpenAiContentItem[]
+  currency: string
+  /** Order total, major units. */
+  value: number
+  /** The order's display id — the dedup key shared with the server. */
+  displayId: string | number
+}): void {
+  const oaiq = safeOaiq()
+  if (!oaiq) return
+  oaiq(
+    "measure",
+    "order_created",
+    {
+      type: "contents",
+      amount: minorUnits(data.value),
+      currency: data.currency,
+      contents: data.contents,
+    } satisfies OpenAiEventData,
+    { event_id: openAiOrderEventId(data.displayId) }
+  )
+}
+
+/**
+ * Push a live consent decision to the pixel.
+ *
+ * Normally you do NOT call this: `applyConsent()` in ./consent.ts relays
+ * every decision to gtag, fbq, ttq and oaiq together. Exported for a host
+ * app driving the pixel from a consent layer of its own.
+ *
+ * Their own gate, from the measurement-pixel docs: with consent false the
+ * pixel sends no measurement pings, and the default is TRUE, which is why
+ * the loader closes it explicitly before init rather than trusting it.
+ */
+export function applyOpenAiConsent(adsGranted: boolean): void {
+  const oaiq = safeOaiq()
+  if (!oaiq) return
+  oaiq("consent", adsGranted)
+}

package/src/tracking/storefront-tags.tsx

@@ -4,6 +4,7 @@ import { PageViews } from "./page-views"
 import { Gtm } from "./gtm"
 import { MetaPixel } from "./meta-pixel"
 import { TikTokPixel } from "./tiktok-pixel"
+import { ChatGptPixel } from "./chatgpt-pixel"
 import { getTrackingConfig } from "./get-tracking-config"
 import type { StorefrontClient } from "../api/http"
 import type { TrackingConfig } from "./types"
@@ -65,6 +66,7 @@ export async function StorefrontTags({
       <LiveHeartbeat />
       <MetaPixel pixelId={tracking.facebookPixel?.pixelId} />
       <TikTokPixel pixelId={tracking.tiktok?.pixelId} />
+      <ChatGptPixel pixelId={tracking.chatgptAds?.pixelId} />
       <GoogleTag
         measurementId={tracking.ga4?.measurementId}
         adsConversionId={tracking.googleAds?.conversionId}

package/src/tracking/types.ts

@@ -44,6 +44,10 @@ export type TrackingConfig = {
    *  read by the order.placed forwarder, exactly like Meta's CAPI token,
    *  which has never traversed this surface. */
   tiktok?: { pixelId: string }
+  /** ChatGPT Ads, pixel id ONLY — the Conversions API key is a bearer
+   *  token and stays on the platform, read by the order.placed forwarder
+   *  (chatgpt-ads-pixel card). */
+  chatgptAds?: { pixelId: string }
   /** True when the store's consent CMP is enabled — client tags must
    *  mount through the consent gate (`_1c_consent` / Consent Mode v2). */
   consent_required?: boolean

package/src/cart-drawer/labels-bg.ts

@@ -1,72 +0,0 @@
-import type { CartDrawerLabels } from "./labels"
-
-/**
- * Bulgarian translations for the cart drawer.
- *
- * Ships alongside the English defaults so Bulgarian stores get the
- * translated copy with a single import instead of hand-writing every
- * string. Strings match the originals from mindpages-storefront, plus the
- * Cartbase summary-breakdown row additions.
- *
- * Usage in a store's layout:
- *
- *   import {
- *     CartDrawerProvider,
- *     bulgarianCartDrawerLabels,
- *   } from "@cartbase/storefront/cart-drawer"
- *
- *   <CartDrawerProvider cart={cart} labels={bulgarianCartDrawerLabels}>
- *     ...
- *   </CartDrawerProvider>
- *
- * For multi-language stores, pick the matching labels object at render
- * time based on the active locale (the store owns its locale cookie; see
- * docs/storefront/regions.md for the locale catalog).
- */
-
-export const bulgarianCartDrawerLabels: CartDrawerLabels = {
-  yourCart: "Вашата кошница",
-  item: "артикул",
-  items: "артикула",
-  closeCart: "Затвори кошницата",
-
-  emptyCartTitle: "Кошницата е празна",
-  emptyCartMessage: "Все още нямате добавени продукти.",
-  browseProducts: "Разгледай продуктите",
-
-  awayFromFreeShipping: "до безплатна доставка",
-  allRewardsUnlocked: "Всички награди са отключени",
-
-  addGiftWrap: "Добави подаръчна опаковка",
-  giftNote: "Картичка",
-  orderNote: "Бележка",
-  giftNotePlaceholder: "Добави лично съобщение...",
-  orderNotePlaceholder: "Специални инструкции за поръчката...",
-
-  estimatedRewardPoints: "Очаквани точки за награда",
-
-  pairsWellWith: "Подходящи допълнения",
-  youllLoveThis: "Ще ви хареса",
-  youMightAlsoLike: "Може да ви хареса",
-  addToCart: "Добави",
-
-  subtotal: "Междинна сума",
-  taxAndShipping: "С включен ДДС. Доставката се изчислява при плащане.",
-  shipping: "Доставка",
-  free: "БЕЗПЛАТНА",
-  calculatedAtCheckout: "Изчислява се при плащане",
-  total: "Общо",
-  secureCheckout: "Към поръчка",
-  shippingAndTaxCalculatedAtCheckout:
-    "Доставката и данъкът се изчисляват при плащане",
-
-  discount: "Отстъпка",
-  tax: "ДДС",
-  paymentMethodFee: "Такса за плащане",
-  giftCard: "Подаръчна карта",
-  remainingToPay: "Остава за плащане",
-
-  continueShopping: "Продължи пазаруването",
-
-  remove: "Премахни",
-}