@cartbase/storefront 0.22.0 → 0.23.0

package/src/api/integrations.ts

@@ -219,7 +219,10 @@ export interface PickupPointsResponse {
  * platform's where it does not (Econt and BoxNow publish whole catalogues,
  * held per store for ten minutes and ranked so a town's own offices beat an
  * office on a street that shares the town's name). A storefront sends the
- * query and gets the right answer either way.
+ * query and gets the right answer either way.
+ * `catalogue: true` instead returns ALL eligible points (q/limit ignored),
+ * so a picker can rank before slicing. `locale` selects Speedy's BG/EN
+ * display names; automated terminals are excluded from office catalogues.
  *
  * Auth: anon (the store's key).
  * Errors: 400 when `mode` is missing or the carrier does not serve it, 404
@@ -228,11 +231,13 @@ export interface PickupPointsResponse {
 export async function listPickupPoints(
   client: StorefrontClient,
   provider: string,
-  opts: { mode: "office" | "locker"; q?: string; limit?: number }
+  opts: { mode: "office" | "locker"; q?: string; limit?: number; catalogue?: boolean; locale?: string }
 ): Promise<PickupPointsResponse> {
   const query = new URLSearchParams({ mode: opts.mode })
   if (opts.q) query.set("q", opts.q)
-  if (opts.limit) query.set("limit", String(opts.limit))
+  if (opts.limit) query.set("limit", String(opts.limit))
+  if (opts.catalogue) query.set("catalogue", "true")
+  if (opts.locale) query.set("locale", opts.locale)
   return client.get(
     `/api/store/integrations/${encodeURIComponent(provider)}/pickup-points?${query.toString()}`
   )

package/src/checkout/carrier-marks.ts

@@ -1,53 +1,14 @@
-/**
- * The carrier's own mark beside its name on a checkout shipping row.
- *
- * A shopper picks a courier by recognising it, and until 2026-09-18 a store
- * got names only unless it hunted down logo files and passed a map of its
- * own (store-package card). The marks are the platform's: the same files
- * the admin's integrations screens wear, served from the platform the store
- * already talks to, so a carrier we add tomorrow arrives with its mark and
- * no store copies an image anywhere.
- *
- * Keyed by the carrier's fulfillment option id, which the platform's
- * registry owns and a shipping option carries in `data.id`. Both modes of a
- * carrier wear the same mark: it names the courier, not the destination.
- */
-
-const MARK: Record<string, { carrier: string; alt: string }> = {
-  "econt-address": { carrier: "econt", alt: "Econt" },
-  "econt-office": { carrier: "econt", alt: "Econt" },
-  "speedy-address": { carrier: "speedy", alt: "Speedy" },
-  "speedy-office": { carrier: "speedy", alt: "Speedy" },
-  "boxnow-locker": { carrier: "boxnow", alt: "BOX NOW" },
-  "pigeon-address": { carrier: "pigeon", alt: "Pigeon Express" },
-  "pigeon-office": { carrier: "pigeon", alt: "Pigeon Express" },
-  "pigeon-locker": { carrier: "pigeon", alt: "Pigeon Express" },
-}
+import type { StoreShippingOption } from "../api/checkout"
 
 /**
- * The default `logoByFulfillmentOptionId` map for a checkout's shipping
- * list. A store that passes its own map keeps it: this is the floor, not a
- * ceiling.
- *
- * `origin` is the SDK client's own (`client.origin`), which in a storefront
- * is the shop's own address, because the store API ships no CORS headers and
- * every storefront reaches it through a same-origin `/api/store/*` rewrite.
- * So the mark is asked for under that same path, which is the one address a
- * storefront can always reach; the platform answers it with the file it
- * already serves. Pointing at the platform's own `/integrations/…` instead
- * is what made every mark 404, since that path is not proxied and the shop's
- * own domain has no such file (found on the workbench before release).
+ * The carrier's mark beside its checkout row. Identity and the same-origin
+ * mark path arrive resolved by the platform adapter; the package keeps no
+ * carrier list.
  */
-export function carrierMarks(
-  origin: string
-): Record<string, { src: string; alt: string }> {
-  const base = origin.replace(/\/+$/, "")
-  const marks: Record<string, { src: string; alt: string }> = {}
-  for (const [optionId, mark] of Object.entries(MARK)) {
-    marks[optionId] = {
-      src: `${base}/api/store/integrations/marks/${mark.carrier}`,
-      alt: mark.alt,
-    }
-  }
-  return marks
+export function carrierMark(
+  option: Pick<StoreShippingOption, "carrier">
+): { src: string; alt: string } | null {
+  const carrier = option.carrier
+  if (!carrier?.mark_url) return null
+  return { src: carrier.mark_url, alt: carrier.name }
 }

package/src/checkout/checkout-client.tsx

@@ -7,7 +7,6 @@ import type { Cart } from "../api/carts"
 import type { StoreShippingOption } from "../api/checkout"
 import type { StoreCustomer } from "../api/customers"
 import { CheckoutAddressForm } from "./address-form"
-import { carrierMarks } from "./carrier-marks"
 import { DiscountSection } from "./discount-section"
 import { MobileCheckoutBottomBar } from "./mobile-checkout-bottom-bar"
 import { MobileCheckoutTopBar } from "./mobile-checkout-top-bar"
@@ -214,11 +213,7 @@ export function CheckoutClient({
                 userCity: o.formData["shipping_address.city"] ?? "",
                 userAddress: o.formData["shipping_address.address_1"] ?? "",
               }}
-              // Every carrier wears its own mark without the store lifting a
-              // finger; a store that passes its own map keeps it.
-              logoByFulfillmentOptionId={
-                logoByFulfillmentOptionId ?? carrierMarks(client.origin)
-              }
+              logoByFulfillmentOptionId={logoByFulfillmentOptionId}
             />
 
             <CheckoutPaymentMethodList

package/src/checkout/fulfillment-option.ts

@@ -16,8 +16,10 @@ import type { StoreShippingOption } from "../api/checkout"
  * because a cart carried over from that platform still speaks it.
  */
 export function fulfillmentOptionId(
-  option: Pick<StoreShippingOption, "data"> | null | undefined
+  option: Pick<StoreShippingOption, "data" | "carrier"> | null | undefined
 ): string | null {
+  const resolved = option?.carrier?.fulfillment_option?.id
+  if (typeof resolved === "string" && resolved) return resolved
   const data = option?.data as
     | { fulfillment_option?: unknown; id?: unknown }
     | null

package/src/checkout/index.ts

@@ -44,7 +44,7 @@ export {
   type PickupPoint,
 } from "./pickup-point-selector"
 export { pickupOptionOf, type PickupOption } from "./pickup-option"
-export { carrierMarks } from "./carrier-marks"
+export { carrierMark } from "./carrier-marks"
 export { AddressSelect } from "./address-select"
 export { CompanyDetails } from "./company-details"
 export { DiscountSection } from "./discount-section"

package/src/checkout/pickup-option.ts

@@ -1,11 +1,11 @@
+import type { StoreShippingOption } from "../api/checkout"
+
 /**
  * Does this shipping option deliver to a POINT, and to whose?
  *
- * Every carrier names its fulfillment options `<carrier>-<mode>`, because the
- * platform's registry declares them that way and the same ids key the carrier
- * marks and the order's own destination editor. So one reader answers for all
- * of them, and a carrier connected tomorrow opens its picker with no line
- * added anywhere.
+ * The platform resolves provider, mode and picker scope through the carrier
+ * adapter. The string form remains as rollout compatibility for older store
+ * API responses.
  *
  * `address` is the door: there is no point to choose, so it answers null.
  *
@@ -17,19 +17,43 @@
  */
 
 export type PickupOption = {
-  /** `econt`, `speedy`, `boxnow`, `pigeon`. */
+  /** Carrier adapter id. */
   provider: string
   mode: "office" | "locker"
+  scope: "city" | "global"
 }
 
 export function pickupOptionOf(
-  fulfillmentOptionId: string | null | undefined
+  input:
+    | string
+    | Partial<Pick<StoreShippingOption, "carrier" | "data">>
+    | null
+    | undefined
 ): PickupOption | null {
+  if (typeof input === "object" && input) {
+    const carrier = input.carrier
+    const mode = carrier?.fulfillment_option?.mode
+    if (carrier && (mode === "office" || mode === "locker")) {
+      return { provider: carrier.id, mode, scope: carrier.pickup_scope }
+    }
+    const data = input.data as
+      | { fulfillment_option?: unknown; id?: unknown }
+      | null
+      | undefined
+    const legacy =
+      typeof data?.fulfillment_option === "string"
+        ? data.fulfillment_option
+        : typeof data?.id === "string"
+          ? data.id
+          : null
+    return pickupOptionOf(legacy)
+  }
+  const fulfillmentOptionId = input
   if (!fulfillmentOptionId) return null
   const dash = fulfillmentOptionId.lastIndexOf("-")
   if (dash <= 0) return null
   const mode = fulfillmentOptionId.slice(dash + 1)
   if (mode !== "office" && mode !== "locker") return null
   const provider = fulfillmentOptionId.slice(0, dash)
-  return provider ? { provider, mode } : null
+  return provider ? { provider, mode, scope: "global" } : null
 }