@carrierllc/mcp 0.13.41 → 0.13.47

package/templates/storefront/src/vendor/carrier/tiers.ts

@@ -0,0 +1,161 @@
+/**
+ * Speed tiers on the shop.
+ *
+ * Calm and Cruise come from the plans that were loaded. Lightning stays
+ * hidden unless this tenant turned the tier on and every Lightning plan has
+ * a real Stripe Price id. Fixture plans are never shown, and a production
+ * build does not contain them.
+ */
+import { isStripePriceId } from "./stripe-price";
+import type { SkuTemplate } from "./types";
+
+export const SPEED_TIERS = ["Calm", "Cruise", "Lightning"] as const;
+export type SpeedTier = (typeof SPEED_TIERS)[number];
+
+/** Buyer copy. No fixture wording. */
+export const TIER_HELP_COPY = "Pick a data size and how long it lasts.";
+
+export function tierEmptyCopy(tier: SpeedTier): string {
+  return `No ${tier} plans yet.`;
+}
+
+function devLightningFixture(dataGb: number, validityDays: number, priceCents: number): SkuTemplate {
+  return {
+    id: `fixture-lightning-${dataGb}gb-${validityDays}d`,
+    name: "Lightning — test fixture",
+    description: "Test fixture. Not a production plan.",
+    dataGb,
+    validityDays,
+    price_cents: priceCents,
+    currency: "EUR",
+    fixture: true,
+    regions: [],
+    features: [],
+  };
+}
+
+/**
+ * Checkout-refusal samples for tests. Empty in production so the strings and
+ * prices cannot be bundled into a buyer build.
+ */
+export const LIGHTNING_TEST_FIXTURES: readonly SkuTemplate[] =
+  process.env.NODE_ENV === "production"
+    ? []
+    : [
+        devLightningFixture(1, 7, 101),
+        devLightningFixture(3, 7, 202),
+        devLightningFixture(5, 14, 303),
+        devLightningFixture(10, 30, 404),
+      ];
+
+export function speedTierOf(plan: Pick<SkuTemplate, "name" | "id">): SpeedTier | null {
+  const haystack = `${plan.name} ${plan.id}`.toLowerCase();
+  for (const tier of SPEED_TIERS) {
+    if (new RegExp(`(^|[^a-z])${tier.toLowerCase()}([^a-z]|$)`).test(haystack)) return tier;
+  }
+  return null;
+}
+
+/** A plan invented for tests, whatever the tenant flag says. */
+export function isFixturePlan(plan: Pick<SkuTemplate, "id" | "name" | "description" | "fixture">): boolean {
+  if (plan.fixture === true) return true;
+  if (plan.id.startsWith("fixture-")) return true;
+  const copy = `${plan.name} ${plan.description}`;
+  return /test fixture/i.test(copy);
+}
+
+export interface TierCatalogOptions {
+  /**
+   * Per-tenant switch. Off unless the tenant sets
+   * NEXT_PUBLIC_LIGHTNING_TIER=1. Real Stripe Price ids are still required.
+   */
+  lightningEnabled?: boolean;
+}
+
+export interface TierGroup {
+  tier: SpeedTier;
+  plans: SkuTemplate[];
+}
+
+export interface TierCatalogView {
+  tiers: TierGroup[];
+  untiered: SkuTemplate[];
+}
+
+/** True only when the tenant opted in and every Lightning plan has a Price id. */
+export function lightningTierVisible(plans: SkuTemplate[], lightningEnabled: boolean): boolean {
+  if (lightningEnabled !== true) return false;
+  const lightning = plans.filter((plan) => speedTierOf(plan) === "Lightning" && !isFixturePlan(plan));
+  return lightning.length > 0 && lightning.every((plan) => isStripePriceId(plan.stripe_price_id));
+}
+
+/** Tiers a buyer can see. Lightning is omitted until it is configured. */
+export function presentTierCatalog(plans: SkuTemplate[], options: TierCatalogOptions = {}): TierCatalogView {
+  const sellable = plans.filter((plan) => !isFixturePlan(plan));
+  const showLightning = lightningTierVisible(sellable, options.lightningEnabled === true);
+  const tiers = SPEED_TIERS.filter((tier) => tier !== "Lightning" || showLightning).map((tier) => ({
+    tier,
+    plans: sellable.filter((plan) => speedTierOf(plan) === tier),
+  }));
+  return {
+    tiers,
+    untiered: sellable.filter((plan) => speedTierOf(plan) === null),
+  };
+}
+
+/**
+ * The SKU a tier-level select action chooses: the current data and validity,
+ * which for an untouched tier is its first plan. One plan is enough.
+ */
+export function tierChoiceSku(plans: SkuTemplate[]): SkuTemplate | null {
+  return combinations(plans)[0] ?? null;
+}
+
+function uniqueSorted(values: number[]): number[] {
+  const seen: number[] = [];
+  for (const value of values) {
+    if (!seen.includes(value)) seen.push(value);
+  }
+  return seen.sort((a, b) => a - b);
+}
+
+export function dataChoices(plans: SkuTemplate[]): number[] {
+  return uniqueSorted(plans.map((plan) => plan.dataGb));
+}
+
+export function validityChoices(plans: SkuTemplate[], dataGb: number): number[] {
+  return uniqueSorted(plans.filter((plan) => plan.dataGb === dataGb).map((plan) => plan.validityDays));
+}
+
+export function skuFor(plans: SkuTemplate[], dataGb: number, validityDays: number): SkuTemplate | null {
+  return plans.find((plan) => plan.dataGb === dataGb && plan.validityDays === validityDays) ?? null;
+}
+
+/** Every data × validity pair that exists. Missing pairs are not included. */
+export function combinations(plans: SkuTemplate[]): SkuTemplate[] {
+  const chosen: SkuTemplate[] = [];
+  for (const dataGb of dataChoices(plans)) {
+    for (const validityDays of validityChoices(plans, dataGb)) {
+      const sku = skuFor(plans, dataGb, validityDays);
+      if (sku) chosen.push(sku);
+    }
+  }
+  return chosen;
+}
+
+/** Text a production render would show. Fixture prices and labels stay out. */
+export function buyerFacingTierText(plans: SkuTemplate[], options: TierCatalogOptions = {}): string {
+  const view = presentTierCatalog(plans, options);
+  const lines: string[] = [TIER_HELP_COPY];
+  for (const group of view.tiers) {
+    lines.push(group.tier);
+    if (group.plans.length === 0) {
+      lines.push(tierEmptyCopy(group.tier));
+      continue;
+    }
+    for (const sku of combinations(group.plans)) {
+      lines.push(sku.id, sku.name, sku.description, String(sku.price_cents), sku.currency);
+    }
+  }
+  return lines.join("\n");
+}

package/templates/storefront/src/vendor/carrier/types.ts

@@ -11,6 +11,22 @@ export interface SkuTemplate {
   validityDays: number;
   price_cents: number;
   currency: string;
+  /**
+   * Stripe Price id (`price_…`) that checkout charges. The page reads that
+   * Price's `unit_amount` and currency. Absent on sample plans, which must
+   * not be sold.
+   */
+  stripe_price_id?: string;
+  /**
+   * The Stripe Price could not be read. The page must not show `price_cents`,
+   * which is only the catalog copy of an amount checkout does not charge.
+   */
+  price_unavailable?: boolean;
+  /**
+   * True only for a Lightning option drawn from the test-fixture tier when
+   * the loaded catalog has no Lightning plan. Never a production SKU.
+   */
+  fixture?: boolean;
   regions: string[];
   features: string[];
 }
@@ -57,6 +73,12 @@ export interface EsimOrder {
   expiresAt?: string;
   /** Operator-supplied, customer-safe explanation when status is "failed". */
   failureMessage?: string;
+  /** Gigabytes on the plan. Omitted when the plan is unlimited or unknown. */
+  dataGb?: number;
+  /** True only when the plan is explicitly unlimited. */
+  unlimited?: boolean;
+  /** Days the plan stays valid. Omitted when the plan does not say. */
+  validityDays?: number;
   /**
    * The plan is no longer billable. Set once a cancellation has been accepted,
    * so the dashboard can stop offering to cancel it twice.

package/templates/storefront/src/vendor/geo/index.ts

@@ -7,15 +7,26 @@ export function getCountryName(iso: string, locale = "en"): string {
   }
 }
 
+/** Stripe zero-decimal currencies. `unit_amount` is already the major unit. */
+const ZERO_DECIMAL = new Set([
+  "BIF", "CLP", "DJF", "GNF", "JPY", "KMF", "KRW", "MGA", "PYG", "RWF",
+  "UGX", "VND", "VUV", "XAF", "XOF", "XPF",
+]);
+
 export function formatPrice(cents: number, currency = "EUR", locale = "en"): string {
+  const code = currency.toUpperCase();
+  const zeroDecimal = ZERO_DECIMAL.has(code);
+  const major = zeroDecimal ? cents : cents / 100;
+  const digits = zeroDecimal ? 0 : 2;
   try {
     return new Intl.NumberFormat(locale, {
       style: "currency",
-      currency,
-      minimumFractionDigits: 2,
-    }).format(cents / 100);
+      currency: code,
+      minimumFractionDigits: digits,
+      maximumFractionDigits: digits,
+    }).format(major);
   } catch {
-    return `${currency} ${(cents / 100).toFixed(2)}`;
+    return `${code} ${zeroDecimal ? String(major) : major.toFixed(digits)}`;
   }
 }