@lime-bundles/widget 3.2.2 → 3.4.0

package/README.md

@@ -61,11 +61,30 @@ document.querySelector("lime-bundle").addEventListener(
 | `app-url` |  | Enables impression + add-to-cart analytics when set. |
 | `analytics` |  | `"false"` suppresses analytics even when `app-url` is set. |
 | `locale` |  | BCP-47 tag forwarded to the Storefront API. |
+| `country` |  | ISO-3166 alpha-2 (e.g. `"US"`). Adds `@inContext(country:)` to Storefront queries — Markets pricing + currency. |
+| `language` |  | ISO-639-1 (e.g. `"EN"`). Adds `@inContext(language:)`. |
+| `market-id` |  | Current visitor's Market GID. Hides market-restricted bundles whose allow-list doesn't include this market. |
 
 **Product resolution** (when `bundle-gid` is absent): explicit `product-handle` → `<meta name="shopify:product-handle">` → `/products/<handle>` URL segment.
 
 Changing any attribute at runtime re-fetches and re-renders.
 
+### B2B buyer identity (programmatic property only)
+
+`buyer` is **not** an HTML attribute. Set it on the element after creation so the customer access token never lands in DOM-snapshot tools (Sentry, analytics, browser extensions) or Referer headers:
+
+```js
+const el = document.querySelector("lime-bundle");
+el.buyer = async () => {
+  // Resolved per request — no token in static markup
+  return { customerAccessToken: await fetchToken(), companyLocationId: "gid://shopify/CompanyLocation/9" };
+};
+```
+
+The Customer Account API PKCE flow is the canonical token source. See https://shopify.dev/docs/api/customer/latest.
+
+Buyer-contextual Storefront responses MUST be `Cache-Control: private` — never share across users.
+
 ## Events
 
 All events bubble and pierce shadow-DOM boundaries (`composed: true`), so you can listen on any ancestor.

package/dist/index.cjs

@@ -4130,8 +4130,19 @@ var LimeBundleElement = class extends HTMLElement {
     "product-handle",
     "app-url",
     "analytics",
-    "locale"
+    "locale",
+    "country",
+    "language",
+    "market-id"
   ];
+  /**
+   * B2B buyer identity. Set programmatically — `element.buyer = {...}` or
+   * `element.buyer = () => fetchToken()`. NEVER expose as an HTML attribute
+   * because the customer access token would land in DOM snapshots (Sentry,
+   * analytics, browser extensions) and Referer headers. See the package
+   * README ("Markets & B2B").
+   */
+  buyer = void 0;
   shadow;
   bundles = [];
   abortController = null;
@@ -4194,6 +4205,40 @@ var LimeBundleElement = class extends HTMLElement {
   get analyticsEnabled() {
     return this.getAttribute("analytics") !== "false";
   }
+  get country() {
+    return this.getAttribute("country") ?? void 0;
+  }
+  get language() {
+    return this.getAttribute("language") ?? void 0;
+  }
+  get marketId() {
+    return this.getAttribute("market-id") ?? void 0;
+  }
+  /**
+   * Returns the @inContext-wrapped query when any context field is set;
+   * otherwise the plain query. Keeps responses publicly cacheable when
+   * no buyer/country/language is set.
+   */
+  wrapQueryForContext(query) {
+    return (0, import_core8.hasInContext)({
+      shopDomain: this.shopDomain,
+      accessToken: this.storefrontToken,
+      country: this.country,
+      language: this.language,
+      buyer: this.buyer
+    }) ? (0, import_core8.withInContext)(query) : query;
+  }
+  /**
+   * Returns true if this bundle should be hidden for the current market.
+   * For "all" bundles, always returns false (visible). For "specific"
+   * bundles, returns true when no marketId was set or when the bundle's
+   * marketIds doesn't include the configured market.
+   */
+  isMarketHidden(bundle) {
+    if (bundle.marketVisibility !== "specific") return false;
+    if (!this.marketId) return true;
+    return !bundle.marketIds.includes(this.marketId);
+  }
   async fetchBundle() {
     if (!this.shopDomain || !this.storefrontToken) {
       this.renderError(
@@ -4207,7 +4252,10 @@ var LimeBundleElement = class extends HTMLElement {
     this.renderLoading();
     const client = (0, import_core8.createStorefrontClient)({
       shopDomain: this.shopDomain,
-      accessToken: this.storefrontToken
+      accessToken: this.storefrontToken,
+      country: this.country,
+      language: this.language,
+      buyer: this.buyer
     });
     try {
       let bundlePromise;
@@ -4246,7 +4294,7 @@ var LimeBundleElement = class extends HTMLElement {
         const sanitized = (0, import_core8.sanitizeCustomCss)(css.shop.metafield.value);
         if (sanitized.ok) this.shopCustomCss = sanitized.css;
       }
-      await this.applyABVariants();
+      await this.applyLinkGroupVariants();
       this.renderBundles();
     } catch (err) {
       if (controller.signal.aborted) return;
@@ -4258,40 +4306,54 @@ var LimeBundleElement = class extends HTMLElement {
     }
   }
   /**
-   * Resolve the visitor's A/B bucket for every bundle with an active test
-   * and merge Variant B overrides where applicable. Runs in parallel; any
-   * assignment failure logs internally but still renders Variant A (safe
-   * default). The `getABTestAssignment` helper persists the bucket via a
-   * first-party cookie; variant attribution is recorded server-side from
-   * the analytics events the widget already emits.
+   * Resolve the visitor's assigned variant for every primary bundle in a link
+   * group. Runs in parallel; any assignment failure logs internally and still
+   * renders the primary (safe default). The `getLinkGroupAssignment` helper
+   * persists the bucket via a first-party cookie; variant attribution is
+   * recorded server-side from the cart-line `_lime_bundle_gid` + `_lime_link_group`
+   * attributes the cart-add path stamps when an assignment lands on a non-primary
+   * variant.
+   *
+   * When the assignment points to a non-primary variant the SDK swaps in that
+   * variant's `ParsedBundle` from the primary's `linkGroup.variants` list. The
+   * variant data must already be present in the storefront query response — the
+   * SDK does NOT issue a separate metaobject fetch on the hot path.
    */
-  async applyABVariants() {
+  async applyLinkGroupVariants() {
     if (this.bundles.length === 0) return;
+    const bundleLookupByMetaobjectId = /* @__PURE__ */ new Map();
+    for (const b of this.bundles) {
+      bundleLookupByMetaobjectId.set(b.id, b);
+    }
     const results = await Promise.all(
       this.bundles.map(async (bundle) => {
-        if (!bundle.abTestId || !bundle.abVariantB) return bundle;
+        const lg = bundle.linkGroup;
+        if (!lg || !lg.isPrimary || !lg.variants || lg.variants.length < 2) {
+          return bundle;
+        }
         try {
-          const assignment = await (0, import_core8.getABTestAssignment)(
-            bundle.abTestId,
-            bundle.id
+          const assignment = await (0, import_core8.getLinkGroupAssignment)(lg.id, lg.variants);
+          if (!assignment) return bundle;
+          if (assignment.variantMetaobjectId === bundle.id) return bundle;
+          const swap = bundleLookupByMetaobjectId.get(
+            assignment.variantMetaobjectId
           );
-          if (assignment?.variant === "B") {
-            return (0, import_core8.applyABVariantB)(bundle);
-          }
+          if (!swap) return bundle;
+          return swap;
         } catch (err) {
           console.warn(
-            `[lime-bundle] A/B assignment failed for bundle ${bundle.id}; falling back to Variant A.`,
+            `[lime-bundle] link-group assignment failed for bundle ${bundle.id}; falling back to primary.`,
             err
           );
+          return bundle;
         }
-        return bundle;
       })
     );
     this.bundles = results;
   }
   async fetchSingleBundle(client, signal) {
     const data = await client.query(
-      import_core8.BUNDLE_METAOBJECT_QUERY,
+      this.wrapQueryForContext(import_core8.BUNDLE_METAOBJECT_QUERY),
       { id: this.bundleGid },
       { signal }
     );
@@ -4303,11 +4365,11 @@ var LimeBundleElement = class extends HTMLElement {
       data.metaobject.id,
       data.metaobject.fields
     );
-    this.bundles = parsed ? [parsed] : [];
+    this.bundles = parsed && !this.isMarketHidden(parsed) ? [parsed] : [];
   }
   async fetchProductBundles(client, signal, productHandle) {
     const data = await client.query(
-      import_core8.BUNDLES_FOR_PRODUCT_QUERY,
+      this.wrapQueryForContext(import_core8.BUNDLES_FOR_PRODUCT_QUERY),
       { handle: productHandle },
       { signal }
     );
@@ -4319,7 +4381,7 @@ var LimeBundleElement = class extends HTMLElement {
     const bundles = [];
     for (const ref of refs) {
       const parsed = (0, import_core8.parseMetaobjectBundle)(ref.id, ref.fields);
-      if (parsed) bundles.push(parsed);
+      if (parsed && !this.isMarketHidden(parsed)) bundles.push(parsed);
     }
     this.bundles = bundles;
   }