@12-apps/payments-frontend 1.21.0 → 1.21.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@12-apps/payments-frontend",
-  "version": "1.21.0",
+  "version": "1.21.1",
   "type": "module",
   "description": "Browser half of the vendor-agnostic payments platform: plug-and-play MUI components for the per-provider settings page (credential form from each provider's schema, masked hints, verify/enable) and the checkout page (PIX QR + polling, card tokenization, hosted-checkout redirect), plus the headless hooks and fetch clients they build on. Talks only to the host's payments HTTP surface — never to a provider directly. Microfrontend-ready: no app coupling, host injects theme and auth.",
   "exports": {

package/src/components/ProviderConnection.tsx

@@ -163,9 +163,22 @@ function ConnectionSummary(props: {
           />
         </Stack>
       ) : null}
+      {/*
+        The connected sentence names NO platform. It used to open with one
+        adopter's product name, hard-coded — so every other host installing this
+        package told its own merchants that somebody else's product was creating
+        their charges, with no prop to change it. The tell that it was an
+        oversight rather than a decision is the branch right below, which already
+        templates the provider from props.
+
+        Nothing was lost by removing it. The sentence exists to answer ONE
+        question — why no API key had to be copied — and the answer is the OAuth
+        grant, not whose logo is on the page. The subject is the connection
+        itself, which is true for every host and needs no new configuration.
+      */}
       <Typography variant="body2" color="text.secondary">
         {props.connected
-          ? 'Sua conta está conectada. O Future Pay cria as cobranças em seu nome — nenhuma chave precisa ser copiada.'
+          ? 'Sua conta está conectada. As cobranças são criadas em seu nome — nenhuma chave precisa ser copiada.'
           : `Conecte sua conta ${props.displayName} autorizando o acesso no site do provedor. Nenhuma chave precisa ser copiada.`}
       </Typography>
       {props.connected && props.connectedAccount ? (

package/src/components/checkout/hosted-return.ts

@@ -18,7 +18,31 @@ import type { CheckoutOrder } from "./types";
  * unrelated session.
  */
 
-const KEY = "futurepay.checkout.hostedOrder";
+/**
+ * Where the parked order lives, namespaced to this PACKAGE.
+ *
+ * It used to carry one adopter's brand as its namespace, written into every
+ * adopter's browser. A storage key is not a private detail: it is observable
+ * surface, asserted on by `@12-apps/payments-e2e` and visible in devtools to
+ * anyone running the host. The sibling handover in this same folder already got
+ * this right with a `payments:` prefix; this one did not.
+ *
+ * Exported so a host or a spec names it rather than retyping it.
+ */
+export const HOSTED_ORDER_STORAGE_KEY = "payments.checkout.hostedOrder";
+
+/**
+ * The key before the rename, READ ONLY.
+ *
+ * A buyer who left for the provider's page on the old bundle comes back to the
+ * new one with their order parked under the old name. Without this they land on
+ * the plain return screen — the order still settles, because the webhook does
+ * that and never depended on any of this, but the confirmation they were
+ * promised is missing for a reason they could not possibly understand.
+ *
+ * Delete once no session can still be mid-redirect across that deploy.
+ */
+const LEGACY_KEY = "futurepay.checkout.hostedOrder";
 
 /**
  * What a hosted provider appends to the return URL. InfinitePay sends the
@@ -46,7 +70,7 @@ function isReturnTrip(): boolean {
 /** Park the raised order before handing the buyer to the provider's page. */
 export function rememberHostedOrder(order: CheckoutOrder): void {
   try {
-    window.sessionStorage?.setItem(KEY, JSON.stringify(order));
+    window.sessionStorage?.setItem(HOSTED_ORDER_STORAGE_KEY, JSON.stringify(order));
   } catch {
     // Storage disabled or full. The redirect must still happen: the webhook
     // settles the order either way, and refusing to send the buyer to pay
@@ -62,15 +86,37 @@ export function rememberHostedOrder(order: CheckoutOrder): void {
  * of resuming one they never paid. Read-and-clear for the same reason: the
  * resumed view belongs to exactly one return.
  */
-export function takeHostedOrder(): CheckoutOrder | null {
-  if (!isReturnTrip()) return null;
-  let raw: string | null = null;
+/**
+ * The raw parked payload under either key, cleared as it is read.
+ *
+ * Split out from {@link takeHostedOrder} so the storage handling and the
+ * parsing stay separately readable — reading two keys and clearing both put the
+ * combined function over the complexity gate, and the two halves fail for
+ * unrelated reasons anyway (storage disabled vs. a value that is not an order).
+ *
+ * BOTH keys are cleared whichever one answered: this is read-and-clear, and a
+ * legacy entry left behind would let a later return trip resume an order that
+ * was already consumed.
+ */
+function takeParkedPayload(): string | null {
   try {
-    raw = window.sessionStorage?.getItem(KEY) ?? null;
-    window.sessionStorage?.removeItem(KEY);
+    const raw =
+      window.sessionStorage?.getItem(HOSTED_ORDER_STORAGE_KEY) ??
+      window.sessionStorage?.getItem(LEGACY_KEY) ??
+      null;
+    window.sessionStorage?.removeItem(HOSTED_ORDER_STORAGE_KEY);
+    window.sessionStorage?.removeItem(LEGACY_KEY);
+    return raw;
   } catch {
+    // Storage disabled or unavailable — the same "no parked order" as an empty
+    // slot, and the webhook still settles the order regardless.
     return null;
   }
+}
+
+export function takeHostedOrder(): CheckoutOrder | null {
+  if (!isReturnTrip()) return null;
+  const raw = takeParkedPayload();
   if (!raw) return null;
   try {
     const parsed: unknown = JSON.parse(raw);

package/src/index.ts

@@ -87,6 +87,13 @@ export {
 export { type CheckoutHostPorts } from './components/checkout/use-checkout-controller';
 export { PaymentsUnavailable } from './components/checkout/payments-unavailable';
 export { fetchCheckoutConfig } from './components/checkout/client';
+/**
+ * The `sessionStorage` key the hosted-checkout return leg parks the raised
+ * order under. Public because it is already observable — a spec asserting the
+ * handover, or a host clearing storage on sign-out, otherwise retypes the
+ * literal and silently drifts when it changes.
+ */
+export { HOSTED_ORDER_STORAGE_KEY } from './components/checkout/hosted-return';
 // ---------------------------------------------------------------------------
 // Digital wallets (FUT-471/472) — the Google-branded button and the capability
 // read it is gated on. `CheckoutFlow` wires these automatically; they are