@pradip1995/segment-login-template 0.5.15 → 0.5.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pradip1995/segment-login-template",
-  "version": "0.5.15",
+  "version": "0.5.16",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -23,11 +23,6 @@
     "./google-auth-section": "./src/google-auth-section.tsx",
     "./otp-input": "./src/otp-input.tsx"
   },
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "lint": "tsc --noEmit",
-    "test": "node --experimental-strip-types --test src/*.test.ts"
-  },
   "peerDependencies": {
     "@pradip1995/commerce-auth": "^4.0.0",
     "@pradip1995/commerce-core": "^4.0.0",
@@ -40,12 +35,17 @@
     "@pradip1995/commerce-auth": "^4.0.0",
     "@pradip1995/commerce-core": "^4.0.0",
     "@pradip1995/segment-primitives": "^0.4.11",
-    "@pradip1995/segment-tokens": "^0.3.7"
+    "@pradip1995/segment-tokens": "^0.3.14"
   },
   "devDependencies": {
     "@pradip1995/plugin-sdk": "^0.2.0",
     "@types/react": "^19",
     "react": "19.0.3",
     "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "test": "node --experimental-strip-types --test src/*.test.ts"
   }
-}
+}

package/src/account-guest-orders.tsx

@@ -3,9 +3,12 @@
 import type { HttpTypes } from "@medusajs/types"
 import LocalizedLink from "@pradip1995/segment-primitives/localized-link"
 import { formatPrice } from "@pradip1995/segment-primitives/format-price"
-import { presentOrderLines } from "@pradip1995/segment-primitives/order-lines"
 import { logoutGuest } from "@pradip1995/commerce-core/data/guest"
 import { acct } from "./account-theme"
+import {
+  resolveOrderHistoryStatus,
+  type OrderHistoryStatusInput,
+} from "./order-history-status"
 
 export default function AccountGuestOrders({
   orders,
@@ -80,14 +83,11 @@ export default function AccountGuestOrders({
                     Order #{order.display_id}
                   </p>
                   <p className="text-xs text-muted mt-1 capitalize">
-                    {order.status?.replace(/_/g, " ")}
+                    {resolveOrderHistoryStatus(order as OrderHistoryStatusInput).label}
                   </p>
                 </div>
                 <p className="text-sm font-semibold text-brand-accent shrink-0">
-                  {formatPrice(
-                    presentOrderLines(order).paidTotal,
-                    order.currency_code
-                  )}
+                  {formatPrice(order.total, order.currency_code)}
                 </p>
               </LocalizedLink>
             </li>

package/src/account-orders.tsx

@@ -8,6 +8,11 @@ import LocalizedLink from "@pradip1995/segment-primitives/localized-link"
 import { formatPrice } from "@pradip1995/segment-primitives/format-price"
 import { presentOrderLines } from "@pradip1995/segment-primitives/order-lines"
 import { acct } from "./account-theme"
+import {
+  resolveOrderHistoryStatus,
+  type OrderHistoryStatusInput,
+  type OrderHistoryStatusTone,
+} from "./order-history-status"
 
 function isCancelled(order: HttpTypes.StoreOrder) {
   const status = (order.status || "").toLowerCase()
@@ -20,28 +25,26 @@ function canReorder(order: HttpTypes.StoreOrder) {
   return ["delivered", "partially_delivered"].includes(fulfillment)
 }
 
-function statusStyle(order: HttpTypes.StoreOrder) {
-  if (isCancelled(order)) {
+function historyStatus(order: HttpTypes.StoreOrder) {
+  return resolveOrderHistoryStatus(order as OrderHistoryStatusInput)
+}
+
+function statusStyle(tone: OrderHistoryStatusTone) {
+  if (tone === "cancel") {
     return "bg-[#FFF1F2] text-[#BE123C] border-[#BE123C]/20"
   }
-  const s = (order.fulfillment_status || order.status || "").toLowerCase()
-  if (s === "delivered" || s === "complete" || s === "completed") {
+  if (tone === "return") {
+    return "bg-[#FFF7ED] text-[#C2410C] border-[#C2410C]/20"
+  }
+  if (tone === "done") {
     return "bg-[#E6F4F0] text-[#008A5D] border-[#008A5D]/20"
   }
-  if (s.includes("ship")) {
+  if (tone === "shipped") {
     return "bg-[#EBF5FF] text-[#0068D2] border-[#0068D2]/20"
   }
-  if (s.includes("fulfill")) {
-    return "bg-surface-muted text-brand-accent border-brand-accent"
-  }
   return "bg-surface-muted text-muted border-cart-border"
 }
 
-function statusLabel(order: HttpTypes.StoreOrder) {
-  if (isCancelled(order)) return "Cancelled"
-  return (order.fulfillment_status || order.status || "").replace(/_/g, " ")
-}
-
 export default function AccountOrders({
   orders,
 }: {
@@ -66,7 +69,7 @@ export default function AccountOrders({
     if (!q) return safeOrders
     return safeOrders.filter((order) => {
       const id = String(order.display_id ?? order.id)
-      const status = statusLabel(order)
+      const status = historyStatus(order).label
       return id.includes(q) || status.toLowerCase().includes(q)
     })
   }, [safeOrders, query])
@@ -125,7 +128,7 @@ export default function AccountOrders({
       ) : (
         <ul className="space-y-4">
           {filtered.map((order) => {
-            const label = statusLabel(order)
+            const resolved = historyStatus(order)
             const showReorder = canReorder(order)
             const presentation = presentOrderLines(order)
             return (
@@ -141,8 +144,8 @@ export default function AccountOrders({
                       <p className={`font-bold ${acct.heading}`}>
                         Order #{order.display_id}
                       </p>
-                      <span className={`${acct.badge} capitalize ${statusStyle(order)}`}>
-                        {label}
+                      <span className={`${acct.badge} capitalize ${statusStyle(resolved.tone)}`}>
+                        {resolved.label}
                       </span>
                     </div>
                     <p className={`text-xs ${acct.muted}`}>

package/src/order-history-status.test.ts

@@ -0,0 +1,180 @@
+import assert from "node:assert/strict"
+import { describe, it } from "node:test"
+import {
+  resolveOrderHistoryStatus,
+  type OrderHistoryStatus,
+  type OrderHistoryStatusInput,
+} from "./order-history-status.ts"
+
+const CASES: Array<{
+  name: string
+  order: OrderHistoryStatusInput
+  want: OrderHistoryStatus
+}> = [
+  {
+    name: "stays delivered when there is no return",
+    order: { status: "completed", fulfillment_status: "delivered" },
+    want: { label: "Delivered", tone: "done" },
+  },
+  {
+    name: "shows return requested after a return is submitted on a delivered order",
+    order: {
+      status: "completed",
+      fulfillment_status: "delivered",
+      returns: [{ status: "requested" }],
+    },
+    want: { label: "Return Requested", tone: "return" },
+  },
+  {
+    name: "treats a return with no status as requested",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [{ status: null }],
+    },
+    want: { label: "Return Requested", tone: "return" },
+  },
+  {
+    name: "maps open returns to return approved",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [{ status: "open" }],
+    },
+    want: { label: "Return Approved", tone: "return" },
+  },
+  {
+    name: "maps approved returns to return approved",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [{ status: "approved" }],
+    },
+    want: { label: "Return Approved", tone: "return" },
+  },
+  {
+    name: "maps partially received returns to return in progress",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [{ status: "partially_received" }],
+    },
+    want: { label: "Return In Progress", tone: "return" },
+  },
+  {
+    name: "maps received returns to returned",
+    order: {
+      status: "completed",
+      fulfillment_status: "delivered",
+      returns: [{ status: "received" }],
+    },
+    want: { label: "Returned", tone: "return" },
+  },
+  {
+    name: "maps fulfillment returned when returns are missing from the payload",
+    order: { fulfillment_status: "returned" },
+    want: { label: "Returned", tone: "return" },
+  },
+  {
+    name: "maps fulfillment partially returned to return in progress",
+    order: { fulfillment_status: "partially_returned" },
+    want: { label: "Return In Progress", tone: "return" },
+  },
+  {
+    name: "shows refunded when payment is refunded after a return",
+    order: {
+      fulfillment_status: "returned",
+      payment_status: "refunded",
+      returns: [{ status: "received" }],
+    },
+    want: { label: "Refunded", tone: "return" },
+  },
+  {
+    name: "shows refunded for a partial refund",
+    order: {
+      fulfillment_status: "delivered",
+      payment_status: "partially_refunded",
+      returns: [{ status: "requested" }],
+    },
+    want: { label: "Refunded", tone: "return" },
+  },
+  {
+    name: "ignores canceled returns and keeps delivered",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [{ status: "canceled" }, { status: "cancelled" }],
+    },
+    want: { label: "Delivered", tone: "done" },
+  },
+  {
+    name: "ignores exchange and claim returns",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [
+        { status: "requested", exchange_id: "exch_1" },
+        { status: "requested", claim_id: "claim_1" },
+      ],
+    },
+    want: { label: "Delivered", tone: "done" },
+  },
+  {
+    name: "uses the furthest return lifecycle when several returns exist",
+    order: {
+      fulfillment_status: "delivered",
+      returns: [{ status: "requested" }, { status: "received" }],
+    },
+    want: { label: "Returned", tone: "return" },
+  },
+  {
+    name: "cancelled order wins over a return",
+    order: {
+      status: "canceled",
+      fulfillment_status: "delivered",
+      returns: [{ status: "requested" }],
+    },
+    want: { label: "Cancelled", tone: "cancel" },
+  },
+  {
+    name: "shows shipped when not delivered and no return",
+    order: { fulfillment_status: "shipped" },
+    want: { label: "Shipped", tone: "shipped" },
+  },
+  {
+    name: "shows order confirmed for fulfilled orders",
+    order: { fulfillment_status: "fulfilled" },
+    want: { label: "Order Confirmed", tone: "done" },
+  },
+  {
+    name: "shows return requested from item return quantities when returns are omitted",
+    order: {
+      fulfillment_status: "delivered",
+      items: [{ detail: { return_requested_quantity: 1 } }],
+    },
+    want: { label: "Return Requested", tone: "return" },
+  },
+  {
+    name: "shows returned from received item quantities",
+    order: {
+      fulfillment_status: "delivered",
+      items: [{ detail: { return_requested_quantity: 1, return_received_quantity: 1 } }],
+    },
+    want: { label: "Returned", tone: "return" },
+  },
+  {
+    name: "shows return in progress when only some quantity is received",
+    order: {
+      fulfillment_status: "delivered",
+      items: [{ detail: { return_requested_quantity: 2, return_received_quantity: 1 } }],
+    },
+    want: { label: "Return In Progress", tone: "return" },
+  },
+  {
+    name: "shows processing as the default",
+    order: { status: "pending" },
+    want: { label: "Processing", tone: "processing" },
+  },
+]
+
+describe("resolveOrderHistoryStatus", () => {
+  for (const row of CASES) {
+    it(row.name, () => {
+      assert.deepEqual(resolveOrderHistoryStatus(row.order), row.want)
+    })
+  }
+})

package/src/order-history-status.ts

@@ -0,0 +1,170 @@
+export type OrderHistoryStatusTone =
+  | "cancel"
+  | "shipped"
+  | "done"
+  | "return"
+  | "processing"
+
+export type OrderHistoryStatus = {
+  label: string
+  tone: OrderHistoryStatusTone
+}
+
+export type OrderHistoryReturnLike = {
+  status?: string | null
+  exchange_id?: string | null
+  claim_id?: string | null
+}
+
+export type OrderHistoryStatusInput = {
+  status?: string | null
+  fulfillment_status?: string | null
+  payment_status?: string | null
+  returns?: OrderHistoryReturnLike[] | null
+  items?: Array<{
+    detail?: {
+      return_requested_quantity?: number | null
+      return_received_quantity?: number | null
+    } | null
+  }> | null
+}
+
+type ReturnLifecycle =
+  | "requested"
+  | "approved"
+  | "in_progress"
+  | "returned"
+  | "refunded"
+
+const CLOSED_RETURN = new Set(["canceled", "cancelled", "rejected"])
+
+const RETURN_RANK: Record<ReturnLifecycle, number> = {
+  requested: 1,
+  approved: 2,
+  in_progress: 3,
+  returned: 4,
+  refunded: 5,
+}
+
+const RETURN_LABEL: Record<ReturnLifecycle, string> = {
+  requested: "Return Requested",
+  approved: "Return Approved",
+  in_progress: "Return In Progress",
+  returned: "Returned",
+  refunded: "Refunded",
+}
+
+function normalize(value?: string | null) {
+  return (value || "").toLowerCase().trim()
+}
+
+function isStandaloneReturn(ret: OrderHistoryReturnLike) {
+  return !ret.exchange_id && !ret.claim_id
+}
+
+function lifecycleFromReturnStatus(status: string): ReturnLifecycle | null {
+  switch (status) {
+    case "requested":
+      return "requested"
+    case "open":
+    case "approved":
+      return "approved"
+    case "partially_received":
+    case "in_progress":
+      return "in_progress"
+    case "received":
+    case "returned":
+    case "complete":
+    case "completed":
+      return "returned"
+    default:
+      return null
+  }
+}
+
+function pickHigher(
+  current: ReturnLifecycle | null,
+  next: ReturnLifecycle
+): ReturnLifecycle {
+  if (!current) return next
+  return RETURN_RANK[next] > RETURN_RANK[current] ? next : current
+}
+
+function returnLifecycle(order: OrderHistoryStatusInput): ReturnLifecycle | null {
+  const payment = normalize(order.payment_status)
+  let best: ReturnLifecycle | null = null
+
+  if (payment === "refunded" || payment === "partially_refunded") {
+    best = "refunded"
+  }
+
+  for (const ret of order.returns || []) {
+    if (!isStandaloneReturn(ret)) continue
+    const status = normalize(ret.status)
+    if (CLOSED_RETURN.has(status)) continue
+    const life = status
+      ? lifecycleFromReturnStatus(status) ?? "requested"
+      : "requested"
+    best = pickHigher(best, life)
+  }
+
+  let requestedQty = 0
+  let receivedQty = 0
+  for (const item of order.items || []) {
+    requestedQty += Number(item.detail?.return_requested_quantity) || 0
+    receivedQty += Number(item.detail?.return_received_quantity) || 0
+  }
+  if (receivedQty > 0 && requestedQty > receivedQty) {
+    best = pickHigher(best, "in_progress")
+  } else if (receivedQty > 0) {
+    best = pickHigher(best, "returned")
+  } else if (requestedQty > 0) {
+    best = pickHigher(best, "requested")
+  }
+
+  const fulfillment = normalize(order.fulfillment_status)
+  if (fulfillment === "returned") {
+    best = pickHigher(best, "returned")
+  } else if (fulfillment === "partially_returned") {
+    best = pickHigher(best, "in_progress")
+  }
+
+  return best
+}
+
+export function resolveOrderHistoryStatus(
+  order: OrderHistoryStatusInput
+): OrderHistoryStatus {
+  const orderStatus = normalize(order.status)
+  if (orderStatus === "canceled" || orderStatus === "cancelled") {
+    return { label: "Cancelled", tone: "cancel" }
+  }
+
+  const life = returnLifecycle(order)
+  if (life) {
+    return { label: RETURN_LABEL[life], tone: "return" }
+  }
+
+  const fulfillment = normalize(order.fulfillment_status)
+  const combined = fulfillment || orderStatus
+
+  if (combined.includes("cancel")) {
+    return { label: "Cancelled", tone: "cancel" }
+  }
+  if (combined.includes("ship")) {
+    return { label: "Shipped", tone: "shipped" }
+  }
+  if (
+    combined === "delivered" ||
+    combined === "complete" ||
+    combined === "completed" ||
+    combined.includes("fulfill")
+  ) {
+    return {
+      label: combined === "delivered" ? "Delivered" : "Order Confirmed",
+      tone: "done",
+    }
+  }
+
+  return { label: "Processing", tone: "processing" }
+}