@sazito/checkout 0.1.0

package/dist/chunks/labels-ChywPk2i.js

@@ -0,0 +1,1613 @@
+import { CredentialsManager } from '@sazito/client-sdk';
+
+function createStore(initialState) {
+    let state = initialState;
+    const listeners = new Set();
+    return {
+        getState() {
+            return state;
+        },
+        setState(partial) {
+            const patch = typeof partial === 'function' ? partial(state) : partial;
+            state = { ...state, ...patch };
+            listeners.forEach((listener) => listener());
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        }
+    };
+}
+
+function createSdkBinding(options) {
+    const client = options.client;
+    if (!client) {
+        throw new Error('[@sazito/checkout] No client found. Wrap your app with <SazitoProvider client={sazito}> or pass a `client` prop to CheckoutProvider.');
+    }
+    const credentials = getClientCredentialsManager(client) ?? new CredentialsManager();
+    seedCredentials(credentials, options.credentials);
+    return {
+        client,
+        credentials,
+        hasCart() {
+            return credentials.getCartCredentials() !== null;
+        },
+        hasInvoice() {
+            return credentials.getInvoiceCredentials() !== null;
+        }
+    };
+}
+function getClientCredentialsManager(client) {
+    const candidate = client;
+    if (typeof candidate.getCredentialsManager === 'function') {
+        return candidate.getCredentialsManager();
+    }
+    if (candidate.credentialsManager instanceof CredentialsManager) {
+        return candidate.credentialsManager;
+    }
+    return undefined;
+}
+function seedCredentials(credentials, seed) {
+    if (!seed)
+        return;
+    if (seed.cart?.identifier) {
+        credentials.setCartCredentials({ identifier: seed.cart.identifier });
+    }
+    if (seed.invoice?.identifier && typeof seed.invoice.id === 'number') {
+        credentials.setInvoiceCredentials({ id: seed.invoice.id, identifier: seed.invoice.identifier });
+    }
+}
+
+/** Map an HTTP status (per SALES_FLOW docs) to a checkout error code. */
+function codeForStatus(status) {
+    switch (status) {
+        case 416:
+            return 'min_basket';
+        case 418:
+            return 'rate_limited';
+        case 422:
+            return 'cart_invalid';
+        case 423:
+            return 'invoice_locked';
+        default:
+            return undefined;
+    }
+}
+const MESSAGES = {
+    no_cart: {
+        fa: 'سبد خریدی یافت نشد. لطفاً ابتدا یک سبد خرید ایجاد کنید.',
+        en: 'No cart found. Please create a cart first.'
+    },
+    no_invoice: {
+        fa: 'فاکتوری یافت نشد.',
+        en: 'No invoice found.'
+    },
+    min_basket: {
+        fa: 'حداقل مبلغ سبد خرید رعایت نشده است.',
+        en: 'Minimum basket amount not reached.'
+    },
+    rate_limited: {
+        fa: 'درخواست‌های زیادی ارسال شد. کمی صبر کنید.',
+        en: 'Too many requests. Please wait a moment.'
+    },
+    cart_invalid: {
+        fa: 'سبد خرید نامعتبر است و بازنشانی شد.',
+        en: 'Cart is invalid and was reset.'
+    },
+    invoice_locked: {
+        fa: 'فاکتور قفل شده است. لطفاً صفحه را بازخوانی کنید.',
+        en: 'Invoice is locked. Please reload the page.'
+    },
+    stock_violated: {
+        fa: 'موجودی برخی از محصولات سبد خرید رزرو شده یا کافی نیست.',
+        en: 'Some products are out of stock or reserved.'
+    },
+    shipping_required: {
+        fa: 'لطفاً روش ارسال را انتخاب کنید.',
+        en: 'Please select a shipping method.'
+    },
+    address_required: {
+        fa: 'لطفاً اطلاعات ارسال را کامل وارد کنید.',
+        en: 'Please complete the shipping information.'
+    },
+    payment_failed: {
+        fa: 'پرداخت ناموفق بود. لطفاً دوباره تلاش کنید.',
+        en: 'Payment failed. Please try again.'
+    },
+    network: {
+        fa: 'خطای ارتباط با سرور. لطفاً دوباره تلاش کنید.',
+        en: 'Network error. Please try again.'
+    },
+    validation: {
+        fa: 'اطلاعات واردشده نامعتبر است.',
+        en: 'The provided information is invalid.'
+    },
+    unknown: {
+        fa: 'خطای ناشناخته‌ای رخ داد.',
+        en: 'An unexpected error occurred.'
+    }
+};
+function messageForCode(code, locale) {
+    return MESSAGES[code][locale];
+}
+function fromSdkError(error, locale, step) {
+    const code = codeForStatus(error.status) ??
+        (error.type === 'network' ? 'network' : error.type === 'validation' ? 'validation' : 'unknown');
+    // Prefer the server message when present, otherwise the localized default.
+    const message = error.message?.trim() || messageForCode(code, locale);
+    return { message, code, status: error.status, step };
+}
+function makeError(code, locale, step) {
+    return { message: messageForCode(code, locale), code, step };
+}
+
+function makeEvent(name, data) {
+    return {
+        name,
+        step: data?.step,
+        value: data?.value,
+        metadata: data?.metadata,
+        timestamp: Date.now()
+    };
+}
+
+/**
+ * Performs a gateway POST by building and submitting a hidden HTML form,
+ * matching the legacy `action: 'POST'` payment behavior.
+ */
+function submitPostForm(url, fields) {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const form = document.createElement('form');
+    form.method = 'POST';
+    form.action = url;
+    form.style.display = 'none';
+    Object.entries(fields).forEach(([name, value]) => {
+        const input = document.createElement('input');
+        input.type = 'hidden';
+        input.name = name;
+        input.value = value == null ? '' : String(value);
+        form.appendChild(input);
+    });
+    document.body.appendChild(form);
+    form.submit();
+}
+/**
+ * Build the default browser executor. `onEvent` (from config) receives `emit`
+ * effects so analytics adapters can subscribe.
+ */
+function createBrowserEffectExecutor(config) {
+    return (effect) => {
+        switch (effect.type) {
+            case 'redirect':
+                if (typeof window !== 'undefined') {
+                    window.location.href = effect.url;
+                }
+                return;
+            case 'post-form':
+                submitPostForm(effect.url, effect.fields);
+                return;
+            case 'emit':
+                config?.onEvent?.(effect.event);
+                return;
+        }
+    };
+}
+/** A no-op executor for SSR / tests. */
+const noopEffectExecutor = () => { };
+
+const idStr = (value) => String(value);
+function emptyAddressForm() {
+    return {
+        firstName: '',
+        lastName: '',
+        mobilePhone: '',
+        email: '',
+        phoneNumber: '',
+        regionId: null,
+        cityId: null,
+        postalCode: '',
+        address: '',
+        description: ''
+    };
+}
+/**
+ * After regions load, the city ID stored in the invoice address may not match
+ * any city in the regions list (different ID schemes). Try to match by city
+ * name; if no match, reset cityId so the user can pick again.
+ */
+function reconcileAddressWithRegions(form, regions, savedCityName) {
+    if (form.regionId == null)
+        return form;
+    const region = regions.find((r) => r.id === form.regionId);
+    if (!region)
+        return { ...form, regionId: null, cityId: null };
+    if (form.cityId != null && region.cities.some((c) => c.id === form.cityId)) {
+        return form; // already valid
+    }
+    if (savedCityName) {
+        const match = region.cities.find((c) => c.name === savedCityName);
+        if (match)
+            return { ...form, cityId: match.id };
+    }
+    return { ...form, cityId: null };
+}
+/* Accepts both saved-address shapes: standalone addresses carry `city` at the
+   top level, invoice addresses nest it under `region.city`. */
+function addressFormFromSavedAddress(addr) {
+    const base = emptyAddressForm();
+    if (!addr) {
+        return base;
+    }
+    const nestedCity = addr.region?.city;
+    const topLevelCity = addr.city;
+    return {
+        firstName: addr.firstName ?? '',
+        lastName: addr.lastName ?? '',
+        mobilePhone: addr.mobilePhone ?? '',
+        email: addr.email ?? '',
+        phoneNumber: addr.phoneNumber ?? '',
+        regionId: addr.region?.id ?? null,
+        cityId: nestedCity?.id ?? topLevelCity?.id ?? null,
+        postalCode: addr.postalCode ?? '',
+        address: addr.address ?? '',
+        description: addr.description ?? ''
+    };
+}
+function addressFormFromInvoice(invoice) {
+    return addressFormFromSavedAddress(invoice?.shippingAddress);
+}
+/** City name of a saved address regardless of shape — used to reconcile
+    region/city ids against the loaded regions list. */
+function savedAddressCityName(addr) {
+    if (!addr)
+        return undefined;
+    return (addr.region?.city?.name ??
+        addr.city?.name);
+}
+function isAddressComplete(form, needsShipping, postalCodeMandatory = false, emailMandatory = false) {
+    const hasContact = form.firstName.trim() !== '' &&
+        form.lastName.trim() !== '' &&
+        form.mobilePhone.trim() !== '' &&
+        (!emailMandatory || form.email.trim() !== '');
+    if (!needsShipping) {
+        return hasContact;
+    }
+    return (hasContact &&
+        form.regionId != null &&
+        form.cityId != null &&
+        (!postalCodeMandatory || form.postalCode.trim() !== '') &&
+        form.address.trim() !== '');
+}
+/** Has the form diverged from what's saved on the invoice? */
+function isAddressDirty(form, invoice) {
+    const saved = addressFormFromInvoice(invoice);
+    return Object.keys(form).some((key) => form[key] !== saved[key]);
+}
+function uniqueRates(rates) {
+    const seen = new Set();
+    const out = [];
+    for (const rate of rates) {
+        if (!seen.has(rate.id)) {
+            seen.add(rate.id);
+            out.push(rate);
+        }
+    }
+    return out;
+}
+/**
+ * Group invoice items into shippable bundles with their switchable rates and
+ * the currently selected rate. Digital-only invoices yield an empty list.
+ *
+ * The Sazito API returns:
+ *   groupedShippingRates  — all applicable rates per "bundle" (keyed by group ID)
+ *   itemsShippingRate     — one entry per item with its DEFAULT/current rate
+ *
+ * The default rate ID in itemsShippingRate may NOT match any rate in
+ * groupedShippingRates (different IDs for the same method type). We therefore
+ * assign items by the currently ASSIGNED rate from invoice.shippingItems first,
+ * then fall back to the default rate, and finally use positional assignment
+ * (all physical items in the single group when there is only one group).
+ */
+function deriveShippingGroups(invoice, applicable) {
+    if (!invoice || !invoice.needsShipping || !applicable) {
+        return [];
+    }
+    const itemById = new Map(invoice.items.map((item) => [idStr(item.id), item]));
+    // Exclude digital items — they never go through physical shipping groups.
+    const physicalItemsRate = (applicable.itemsShippingRate ?? []).filter((isr) => {
+        const item = itemById.get(idStr(isr.invoiceItemId));
+        return !item || item.productType !== 'digital';
+    });
+    if (physicalItemsRate.length === 0)
+        return [];
+    const physicalItemIds = physicalItemsRate.map((isr) => idStr(isr.invoiceItemId));
+    // item -> currently assigned rate id (from the saved invoice assignment)
+    const assignedRateById = new Map();
+    for (const si of invoice.shippingItems ?? []) {
+        for (const itemId of si.invoiceItemIds) {
+            assignedRateById.set(idStr(itemId), si.rate.id);
+        }
+    }
+    // item -> default rate from applicable methods
+    const defaultRateByItem = new Map();
+    for (const isr of physicalItemsRate) {
+        defaultRateByItem.set(idStr(isr.invoiceItemId), isr.shippingRate);
+    }
+    const resolveItems = (ids) => ids.map((id) => itemById.get(id)).filter((i) => Boolean(i));
+    // Pick selected rate: prefer the saved assignment if it's in the group's rates,
+    // otherwise use the default, otherwise the first rate.
+    const resolveSelected = (itemIds, rates) => {
+        const rateSet = new Set(rates.map((r) => r.id));
+        for (const id of itemIds) {
+            const assigned = assignedRateById.get(id);
+            if (assigned != null && rateSet.has(assigned))
+                return assigned;
+        }
+        for (const id of itemIds) {
+            const def = defaultRateByItem.get(id);
+            if (def && rateSet.has(def.id))
+                return def.id;
+        }
+        // assigned or default rate isn't in this group's rate list — still prefer it
+        for (const id of itemIds) {
+            const assigned = assignedRateById.get(id);
+            if (assigned != null)
+                return assigned;
+        }
+        return rates[0]?.id ?? null;
+    };
+    const groupedEntries = Object.entries(applicable.groupedShippingRates ?? {});
+    // Single group → all physical items belong to it, show ALL its rates.
+    if (groupedEntries.length === 1) {
+        const [key, rates] = groupedEntries[0];
+        const allRates = uniqueRates(rates);
+        return [
+            {
+                key,
+                title: '',
+                itemIds: physicalItemIds,
+                items: resolveItems(physicalItemIds),
+                rates: allRates,
+                selectedRateId: resolveSelected(physicalItemIds, allRates)
+            }
+        ];
+    }
+    // Multiple groups — try to assign items by assigned/default rate membership.
+    if (groupedEntries.length > 1) {
+        const groups = [];
+        for (const [key, rates] of groupedEntries) {
+            const rateSet = new Set(rates.map((r) => r.id));
+            const itemIds = physicalItemsRate
+                .filter((isr) => {
+                const itemId = idStr(isr.invoiceItemId);
+                const assigned = assignedRateById.get(itemId);
+                return (assigned != null && rateSet.has(assigned)) || rateSet.has(isr.shippingRate.id);
+            })
+                .map((isr) => idStr(isr.invoiceItemId));
+            if (itemIds.length === 0)
+                continue;
+            const allRates = uniqueRates(rates);
+            groups.push({
+                key,
+                title: '',
+                itemIds,
+                items: resolveItems(itemIds),
+                rates: allRates,
+                selectedRateId: resolveSelected(itemIds, allRates)
+            });
+        }
+        if (groups.length > 0)
+            return groups;
+    }
+    // Fallback: one group with all physical items and ALL rates from every group.
+    const allRates = uniqueRates([
+        ...Object.values(applicable.groupedShippingRates ?? {}).flat(),
+        ...physicalItemsRate.map((isr) => isr.shippingRate)
+    ]);
+    return [
+        {
+            key: 'all',
+            title: 'shipping',
+            itemIds: physicalItemIds,
+            items: resolveItems(physicalItemIds),
+            rates: allRates,
+            selectedRateId: resolveSelected(physicalItemIds, allRates)
+        }
+    ];
+}
+/** Build the API payload from the current group selections. */
+function buildShippingAssignments(groups) {
+    return groups
+        .filter((group) => group.selectedRateId != null)
+        .map((group) => ({
+        rateId: group.selectedRateId,
+        invoiceItemIds: group.itemIds
+    }));
+}
+/** True once every shippable group has a selected rate. */
+function isShippingComplete(invoice, groups) {
+    if (!invoice?.needsShipping) {
+        return true;
+    }
+    if (groups.length === 0) {
+        return false;
+    }
+    return groups.every((group) => group.selectedRateId != null);
+}
+const codeDiscountTotal = (invoice) => (invoice.couponTotal || 0) + (invoice.discountTotal || 0);
+/**
+ * The documented API contract has no discount "type" field — codes only show
+ * up as totals on the invoice. Classify by comparing the invoice before/after
+ * the code was applied:
+ *   - shipping got cheaper, items total unchanged → free shipping
+ *   - items total dropped by a near-integer %     → percentage
+ *   - items total dropped by anything else        → fixed amount
+ * If the backend ever sends an explicit type on the discount usage
+ * (`discount_type` / `amount_type`), trust it over the heuristics.
+ * `before` is null when the code was restored from a saved invoice; deltas
+ * then fall back to the absolute totals and free shipping is undetectable.
+ */
+function classifyAppliedDiscount(before, after, code) {
+    const amount = Math.max(0, codeDiscountTotal(after) - (before ? codeDiscountTotal(before) : 0));
+    const shippingSaved = before
+        ? Math.max(0, (before.shippingTotal || 0) - (after.shippingTotal || 0))
+        : 0;
+    const base = { code, kind: 'unknown', amount, shippingSaved };
+    const rawUsage = (after.discountUsages?.[0]?.discountCode ?? {});
+    const rawType = [rawUsage.discountType, rawUsage.amountType]
+        .find((v) => typeof v === 'string')
+        ?.toLowerCase();
+    if (rawType) {
+        if (rawType.includes('percent')) {
+            const rawPercent = Number(rawUsage.percent ?? rawUsage.percentage);
+            const percent = Number.isFinite(rawPercent) && rawPercent > 0
+                ? rawPercent
+                : detectPercent(after, amount) ?? undefined;
+            return { ...base, kind: 'percentage', percent };
+        }
+        if (rawType.includes('ship'))
+            return { ...base, kind: 'free_shipping' };
+        if (rawType.includes('fix') || rawType.includes('amount')) {
+            return { ...base, kind: 'fixed_amount' };
+        }
+    }
+    if (amount <= 0) {
+        return shippingSaved > 0 ? { ...base, kind: 'free_shipping' } : base;
+    }
+    const percent = detectPercent(after, amount);
+    return percent != null
+        ? { ...base, kind: 'percentage', percent }
+        : { ...base, kind: 'fixed_amount' };
+}
+/**
+ * A percentage code produces an amount that is a near-exact integer percent of
+ * the items total (raw, or net of item-level discounts). A round fixed amount
+ * can coincidentally match — the misclassification only changes the badge
+ * label, and both readings are true statements of the saving.
+ */
+function detectPercent(invoice, amount) {
+    const raw = invoice.itemsTotalRawPrice || 0;
+    for (const basis of [raw - (invoice.itemsDiscount || 0), raw]) {
+        if (basis <= 0)
+            continue;
+        const percent = (amount / basis) * 100;
+        const rounded = Math.round(percent);
+        if (rounded >= 1 && rounded <= 100 && Math.abs(percent - rounded) < 0.05) {
+            return rounded;
+        }
+    }
+    return null;
+}
+function selectSummary(invoice) {
+    if (!invoice) {
+        return { lines: [], total: 0 };
+    }
+    const subtotal = invoice.itemsTotalRawPrice || invoice.netTotal || 0;
+    const discount = (invoice.itemsDiscount || 0) + (invoice.discountTotal || 0) + (invoice.couponTotal || 0);
+    const lines = [{ key: 'subtotal', amount: subtotal }];
+    if (discount > 0) {
+        // Backend savings percentage for the "your savings" line; fall back to amount/subtotal.
+        // Keep it fractional — a 5,000 discount on a 23M order is ~0.02%, not 0.
+        const percent = (invoice.customerProfitPercentage || 0) > 0
+            ? invoice.customerProfitPercentage
+            : subtotal > 0
+                ? (discount / subtotal) * 100
+                : 0;
+        lines.push({ key: 'discount', amount: discount, negative: true, percent });
+    }
+    // Only show shipping line once a method has been assigned.
+    if (invoice.needsShipping && (invoice.shippingItems?.length ?? 0) > 0) {
+        lines.push({ key: 'shipping', amount: invoice.shippingTotal || 0, free: !invoice.shippingTotal });
+    }
+    if ((invoice.creditTotal || 0) > 0) {
+        lines.push({ key: 'credit', amount: invoice.creditTotal, negative: true });
+    }
+    if ((invoice.vat || 0) > 0) {
+        lines.push({ key: 'vat', amount: invoice.vat, percent: Math.round(invoice.vatPercent || 0) });
+    }
+    return { lines, total: invoice.finalTotal || 0 };
+}
+/** Items that don't require shipping (digital), for display in the shipping step. */
+function selectDigitalItems(invoice, groups, applicable) {
+    if (!invoice)
+        return [];
+    if (!invoice.needsShipping)
+        return invoice.items;
+    // Before shipping methods are loaded, only explicitly-digital items are known.
+    // Showing everything as "digital" when applicable is null would be wrong.
+    if (applicable == null) {
+        return invoice.items.filter((item) => item.productType === 'digital');
+    }
+    // After shipping methods load: items absent from all groups are non-shippable.
+    const shippable = new Set(groups.flatMap((g) => g.itemIds.map(idStr)));
+    return invoice.items.filter((item) => !shippable.has(idStr(item.id)));
+}
+
+const STEP_ORDER = ['cart', 'shipping', 'payment', 'result'];
+function initialFlags() {
+    return {
+        bootstrapping: false,
+        updatingCart: false,
+        savingAddress: false,
+        loadingShipping: false,
+        selectingRate: false,
+        applyingDiscount: false,
+        loadingPayments: false,
+        placingOrder: false
+    };
+}
+function initialState(config) {
+    const locale = config.locale ?? 'fa';
+    return {
+        step: 'cart',
+        status: 'idle',
+        locale,
+        direction: config.direction ?? (locale === 'fa' ? 'rtl' : 'ltr'),
+        cart: null,
+        invoice: null,
+        regions: [],
+        addressForm: emptyAddressForm(),
+        postalCodeMandatory: false,
+        emailMandatory: false,
+        addressDirty: true,
+        applicable: null,
+        shippingGroups: [],
+        paymentMethods: [],
+        selectedPaymentMethodId: null,
+        discountCode: '',
+        appliedDiscountCode: null,
+        appliedDiscount: null,
+        discountError: null,
+        result: null,
+        error: null,
+        flags: initialFlags()
+    };
+}
+function createCheckoutEngine(options) {
+    const config = options.config ?? {};
+    const binding = createSdkBinding(options);
+    const store = createStore(initialState(config));
+    let effectExecutor = noopEffectExecutor;
+    let lock = Promise.resolve();
+    let addressRevision = 0;
+    // ---- internal helpers -------------------------------------------------
+    const get = () => store.getState();
+    const set = store.setState;
+    function runEffect(effect) {
+        effectExecutor(effect);
+    }
+    function emit(...args) {
+        runEffect({ type: 'emit', event: makeEvent(...args) });
+    }
+    function setFlag(flag, value) {
+        set((prev) => ({ flags: { ...prev.flags, [flag]: value } }));
+    }
+    function setError(error) {
+        set({ error, status: error ? 'error' : 'idle' });
+    }
+    function withLock(fn) {
+        const next = lock.then(fn, fn);
+        lock = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    function recomputeGroups() {
+        const { invoice, applicable } = get();
+        const groups = deriveShippingGroups(invoice, applicable);
+        set({ shippingGroups: groups });
+        return groups;
+    }
+    // ---- SDK steps --------------------------------------------------------
+    /** Fetch cart; returns false (and sets error) when unavailable. */
+    async function loadCart() {
+        if (!binding.hasCart()) {
+            setError(makeError('no_cart', get().locale, 'cart'));
+            return false;
+        }
+        const res = await binding.client.cart.get();
+        if (res.error || !res.data) {
+            setError(fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'cart'));
+            return false;
+        }
+        set({ cart: res.data });
+        return true;
+    }
+    /** Create invoice when missing (checked via state), otherwise refresh it. */
+    async function ensureInvoice() {
+        const res = get().invoice != null
+            ? await binding.client.invoices.refresh()
+            : await binding.client.invoices.create();
+        if (res.error || !res.data) {
+            setError(fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'shipping'));
+            return false;
+        }
+        set({ invoice: res.data });
+        return true;
+    }
+    async function loadRegions() {
+        const res = await binding.client.regions.list();
+        if (res.data) {
+            set({ regions: res.data });
+        }
+    }
+    async function loadGeneralInfo() {
+        const getInfo = binding.client.general?.getInfo;
+        if (!getInfo) {
+            return;
+        }
+        const res = await getInfo.call(binding.client.general);
+        if (res.data) {
+            const postalCodeMandatory = readPostalCodeMandatory(res.data);
+            if (postalCodeMandatory !== undefined) {
+                set({ postalCodeMandatory });
+            }
+            const emailMandatory = readEmailMandatory(res.data);
+            if (emailMandatory !== undefined) {
+                set({ emailMandatory });
+            }
+        }
+    }
+    async function refreshInvoice() {
+        const res = await binding.client.invoices.refresh();
+        if (res.data) {
+            set({ invoice: res.data });
+            recomputeGroups();
+        }
+    }
+    async function loadApplicableShipping(expectedAddressRevision) {
+        setFlag('loadingShipping', true);
+        const res = await binding.client.invoices.getApplicableShippingMethods();
+        setFlag('loadingShipping', false);
+        if (addressRevision !== expectedAddressRevision) {
+            return false;
+        }
+        if (res.error || !res.data) {
+            setError(fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'shipping'));
+            return false;
+        }
+        set({ applicable: res.data });
+        recomputeGroups();
+        return true;
+    }
+    async function assignCurrentShipping() {
+        const groups = get().shippingGroups;
+        const assignments = buildShippingAssignments(groups);
+        if (assignments.length === 0) {
+            return;
+        }
+        const res = await binding.client.invoices.assignShippingMethod(assignments);
+        if (res.error || !res.data) {
+            setError(fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'shipping'));
+            return;
+        }
+        set({ invoice: res.data });
+        recomputeGroups();
+    }
+    async function loadPaymentMethods() {
+        setFlag('loadingPayments', true);
+        const res = await binding.client.payments.getMethods();
+        setFlag('loadingPayments', false);
+        if (res.error || !res.data) {
+            setError(fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'payment'));
+            return;
+        }
+        const methods = res.data;
+        const current = get().selectedPaymentMethodId;
+        const preferred = current ?? methods.find((m) => m.isDefault)?.id ?? methods[0]?.id ?? null;
+        set({ paymentMethods: methods, selectedPaymentMethodId: preferred });
+    }
+    // ---- payment resolution ----------------------------------------------
+    // Push a terminal failure onto the result step (step 4) with a visible message.
+    function failResult(message, err) {
+        set({
+            step: 'result',
+            status: 'idle',
+            result: { status: 'failed', message },
+            error: err ?? null
+        });
+        emit('payment_failed', { step: 'result' });
+    }
+    function handlePaymentAction(action) {
+        switch (action.action) {
+            case 'REDIRECT':
+                if (!action.address) {
+                    console.error('[Sazito Checkout] REDIRECT action has no address:', action);
+                    failResult(makeError('payment_failed', get().locale, 'result').message);
+                    return;
+                }
+                set({ status: 'redirecting' });
+                runEffect({ type: 'redirect', url: action.address });
+                return;
+            case 'POST':
+                if (!action.address) {
+                    console.error('[Sazito Checkout] POST action has no address:', action);
+                    failResult(makeError('payment_failed', get().locale, 'result').message);
+                    return;
+                }
+                set({ status: 'redirecting' });
+                runEffect({
+                    type: 'post-form',
+                    url: action.address,
+                    fields: stringifyFields(action.payload)
+                });
+                return;
+            case 'showOrder':
+                set({
+                    step: 'result',
+                    status: 'idle',
+                    result: { status: 'success', order: action.order }
+                });
+                emit('payment_succeeded', { step: 'result' });
+                return;
+            case 'FAIL':
+                set({
+                    step: 'result',
+                    status: 'idle',
+                    result: { status: 'failed', message: action.message }
+                });
+                emit('payment_failed', { step: 'result' });
+                return;
+            case 'StockViolated':
+                set({
+                    step: 'result',
+                    status: 'idle',
+                    result: { status: 'stock_violated', message: action.message }
+                });
+                setError(makeError('stock_violated', get().locale, 'result'));
+                return;
+            case 'pending':
+                set({ step: 'result', status: 'polling', result: { status: 'pending' } });
+                emit('payment_pending', { step: 'result' });
+                void pollPending();
+                return;
+            case 'UPLOAD':
+                // Card-to-card upload is out of scope for v1; surface a clear failure.
+                set({
+                    step: 'result',
+                    status: 'idle',
+                    result: { status: 'failed', message: action.message }
+                });
+                return;
+            default:
+                // Unknown/unhandled action from the gateway — never stall silently.
+                console.error('[Sazito Checkout] Unhandled payment action:', action);
+                failResult(action.message || makeError('payment_failed', get().locale, 'result').message);
+                return;
+        }
+    }
+    async function pollPending() {
+        const interval = config.pollIntervalMs ?? 15000;
+        const res = await binding.client.payments.pollUntilSettled(undefined, interval);
+        if (res.error || !res.data) {
+            setError(fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'result'));
+            return;
+        }
+        handlePaymentAction(res.data);
+    }
+    // ---- public actions ---------------------------------------------------
+    function goToStep(step) {
+        set({ step, error: null });
+        emit('step_viewed', { step });
+        // When landing on shipping with a complete address but no methods fetched yet,
+        // auto-submit so methods appear without requiring a manual Continue press.
+        if (step === 'shipping') {
+            const { addressForm, invoice, applicable } = get();
+            if (!applicable && isAddressComplete(addressForm, invoice?.needsShipping ?? true, get().postalCodeMandatory, get().emailMandatory)) {
+                void withLock(submitAddressInternal);
+            }
+        }
+    }
+    function isUsableSavedAddress(addr) {
+        return Boolean(addr && (addr.firstName || addr.lastName || addr.address));
+    }
+    /* Authenticated users load their latest account address. Stored credentials
+       are also a safe fallback because createAddress refreshes them every time. */
+    async function loadSavedAddress() {
+        try {
+            if (binding.client.isAuthenticated()) {
+                const res = await binding.client.shipping.listAddresses();
+                const latest = res.data?.find(isUsableSavedAddress);
+                if (latest) {
+                    return latest;
+                }
+                if (res.error) {
+                    console.warn('[Sazito Checkout] account-address prefill failed:', res.error.message);
+                }
+            }
+            if (!binding.credentials.getShippingCredentials()) {
+                return null;
+            }
+            const guestRes = await binding.client.shipping.getAddress();
+            if (guestRes.data && isUsableSavedAddress(guestRes.data)) {
+                return guestRes.data;
+            }
+            console.warn('[Sazito Checkout] guest-address prefill skipped:', guestRes.error?.message ?? 'address response missing usable fields', guestRes.data ?? null);
+        }
+        catch (e) {
+            console.warn('[Sazito Checkout] saved-address prefill failed:', e);
+        }
+        return null;
+    }
+    const actions = {
+        async start() {
+            await withLock(async () => {
+                setFlag('bootstrapping', true);
+                set({ status: 'bootstrapping', error: null });
+                const [cartOk, , , invoiceOk] = await Promise.all([
+                    loadCart(),
+                    loadRegions(),
+                    loadGeneralInfo(),
+                    ensureInvoice()
+                ]);
+                setFlag('bootstrapping', false);
+                if (!cartOk || !invoiceOk) {
+                    return;
+                }
+                const invoice = get().invoice;
+                const hasInvoiceAddress = isUsableSavedAddress(invoice?.shippingAddress);
+                let rawForm = addressFormFromInvoice(invoice);
+                let savedCityName = invoice?.shippingAddress?.region?.city?.name;
+                // Fresh invoices carry no address. Authenticated users get their latest
+                // account address; guests get the address persisted by SDK credentials.
+                if (!hasInvoiceAddress) {
+                    const saved = await loadSavedAddress();
+                    if (saved) {
+                        rawForm = addressFormFromSavedAddress(saved);
+                        savedCityName = savedAddressCityName(saved);
+                    }
+                }
+                // A code applied in an earlier session survives on the invoice — reflect
+                // it as applied (no before-invoice, so the type falls back to totals).
+                const savedCode = invoice?.discountCode?.toUpperCase();
+                set({
+                    status: 'idle',
+                    addressForm: reconcileAddressWithRegions(rawForm, get().regions, savedCityName),
+                    addressDirty: !hasInvoiceAddress,
+                    ...(savedCode && invoice
+                        ? {
+                            appliedDiscountCode: savedCode,
+                            appliedDiscount: classifyAppliedDiscount(null, invoice, savedCode)
+                        }
+                        : {})
+                });
+                emit('checkout_viewed', { step: 'cart' });
+                emit('step_viewed', { step: 'cart' });
+            });
+        },
+        goToStep,
+        back() {
+            const idx = STEP_ORDER.indexOf(get().step);
+            if (idx > 0) {
+                goToStep(STEP_ORDER[idx - 1]);
+            }
+        },
+        async next() {
+            await withLock(async () => {
+                const state = get();
+                setError(null);
+                if (state.step === 'cart') {
+                    set({ status: 'working' });
+                    const ok = await ensureInvoice();
+                    set({ status: 'idle' });
+                    if (ok) {
+                        // A fresh invoice has no address yet. Keep the form hydrated from
+                        // the base SDK's saved address instead of clearing it just before
+                        // the Shipping step becomes visible.
+                        const invoice = get().invoice;
+                        if (isUsableSavedAddress(invoice?.shippingAddress)) {
+                            set({ addressForm: addressFormFromInvoice(invoice) });
+                        }
+                        goToStep('shipping');
+                    }
+                    return;
+                }
+                if (state.step === 'shipping') {
+                    // Phase 1: address not saved yet (or changed) → save it and reveal the
+                    // shipping methods, staying on the shipping step.
+                    const needsSave = state.addressDirty || !state.applicable;
+                    if (needsSave) {
+                        const saved = await submitAddressInternal();
+                        if (!saved)
+                            return;
+                        // Stay on the step so the customer can pick / switch a method.
+                        if (state.invoice?.needsShipping) {
+                            return;
+                        }
+                    }
+                    // Phase 2: methods resolved → validate and proceed to payment.
+                    const invoice = get().invoice;
+                    if (!isShippingComplete(invoice, get().shippingGroups)) {
+                        setError(makeError('shipping_required', state.locale, 'shipping'));
+                        return;
+                    }
+                    set({ status: 'working' });
+                    await loadPaymentMethods();
+                    set({ status: 'idle' });
+                    if (!get().error)
+                        goToStep('payment');
+                    return;
+                }
+                if (state.step === 'payment') {
+                    if (state.selectedPaymentMethodId == null) {
+                        setError(makeError('validation', state.locale, 'payment'));
+                        return;
+                    }
+                    // No review step — finalize directly from payment.
+                    await placeOrderInternal();
+                    return;
+                }
+            });
+        },
+        async updateItemQuantity(cartProductId, variantId, quantity) {
+            await withLock(async () => {
+                if (quantity < 1)
+                    return;
+                setFlag('updatingCart', true);
+                const res = await binding.client.cart.updateItem(cartProductId, variantId, quantity);
+                if (res.data) {
+                    set({ cart: res.data });
+                    // Optimistically update summary from cart data, then confirm with server.
+                    const inv = get().invoice;
+                    if (inv)
+                        set({ invoice: applyCartToInvoice(inv, res.data) });
+                    await refreshInvoice();
+                }
+                else if (res.error) {
+                    setError(fromSdkError(res.error, get().locale, 'cart'));
+                }
+                setFlag('updatingCart', false);
+            });
+        },
+        async removeItem(cartProductId, variantId) {
+            await withLock(async () => {
+                setFlag('updatingCart', true);
+                const res = await binding.client.cart.removeItem(cartProductId, variantId);
+                if (res.data) {
+                    set({ cart: res.data });
+                    const inv = get().invoice;
+                    if (inv)
+                        set({ invoice: applyCartToInvoice(inv, res.data) });
+                    await refreshInvoice();
+                }
+                else if (res.error) {
+                    setError(fromSdkError(res.error, get().locale, 'cart'));
+                }
+                setFlag('updatingCart', false);
+            });
+        },
+        setAddressField(key, value) {
+            const before = get().addressForm;
+            const changed = before[key] !== value || (key === 'regionId' && before.cityId !== null);
+            if (changed) {
+                addressRevision += 1;
+            }
+            set((prev) => {
+                const addressForm = { ...prev.addressForm, [key]: value };
+                // Reset city when region changes.
+                if (key === 'regionId') {
+                    addressForm.cityId = null;
+                }
+                const addressDirty = isAddressDirty(addressForm, prev.invoice);
+                return {
+                    addressForm,
+                    addressDirty,
+                    // Rates are derived from the address snapshot. Never keep showing or
+                    // accepting rates fetched for a different form value.
+                    ...(addressDirty ? { applicable: null, shippingGroups: [] } : {})
+                };
+            });
+            // City selection is a discrete destination change, so refresh rates
+            // automatically. Text inputs still wait for Save/Continue to avoid an
+            // address creation and shipping request on every keystroke.
+            if (changed && key === 'cityId' && value != null && get().step === 'shipping') {
+                const state = get();
+                if (isAddressComplete(state.addressForm, state.invoice?.needsShipping ?? true, state.postalCodeMandatory, state.emailMandatory)) {
+                    void withLock(submitAddressInternal);
+                }
+            }
+        },
+        async submitAddress() {
+            return withLock(submitAddressInternal);
+        },
+        async selectShippingRate(groupKey, rateId) {
+            await withLock(async () => {
+                setFlag('selectingRate', true);
+                set((prev) => ({
+                    shippingGroups: prev.shippingGroups.map((group) => group.key === groupKey ? { ...group, selectedRateId: rateId } : group)
+                }));
+                await assignCurrentShipping();
+                await refreshInvoice();
+                setFlag('selectingRate', false);
+                emit('shipping_rate_selected', { step: 'shipping', metadata: { groupKey, rateId } });
+            });
+        },
+        setDiscountCode(code) {
+            set({ discountCode: code, discountError: null });
+        },
+        async applyDiscount() {
+            await withLock(async () => {
+                const code = get().discountCode.trim();
+                if (!code)
+                    return;
+                setFlag('applyingDiscount', true);
+                set({ discountError: null });
+                const before = get().invoice;
+                const res = await binding.client.invoices.addDiscountCode(code);
+                setFlag('applyingDiscount', false);
+                if (res.error || !res.data) {
+                    // Inline error on the discount field instead of the global banner.
+                    const err = fromSdkError(res.error ?? { message: '', type: 'api' }, get().locale, 'payment');
+                    set({ discountError: err.message });
+                    return;
+                }
+                const applied = classifyAppliedDiscount(before, res.data, code.toUpperCase());
+                set({
+                    invoice: res.data,
+                    appliedDiscountCode: applied.code,
+                    appliedDiscount: applied,
+                    discountError: null
+                });
+                recomputeGroups();
+                emit('discount_applied', { step: 'payment', metadata: { code, kind: applied.kind } });
+            });
+        },
+        async removeDiscount() {
+            await withLock(async () => {
+                // No dedicated remove endpoint; clear the saved code and re-sync.
+                setFlag('applyingDiscount', true);
+                binding.credentials.clearDiscountCode();
+                set({ appliedDiscountCode: null, appliedDiscount: null, discountCode: '', discountError: null });
+                await refreshInvoice();
+                setFlag('applyingDiscount', false);
+                emit('discount_removed', { step: 'payment' });
+            });
+        },
+        selectPaymentMethod(id) {
+            set({ selectedPaymentMethodId: id });
+            emit('payment_method_selected', { step: 'payment', metadata: { id } });
+        },
+        async placeOrder() {
+            await withLock(placeOrderInternal);
+        },
+        async resolvePaymentReturn(params) {
+            await withLock(async () => {
+                set({ step: 'result', status: 'polling', result: { status: 'pending' } });
+                const action = await binding.client.payments.verify(paymentReturnInput(params));
+                if (action.error || !action.data) {
+                    setError(fromSdkError(action.error ?? { message: '', type: 'api' }, get().locale, 'result'));
+                    return;
+                }
+                handlePaymentAction(action.data);
+            });
+        },
+        reset() {
+            addressRevision += 1;
+            set(initialState(config));
+        }
+    };
+    // Internal (lock-free) order placement shared by `placeOrder` & `next` (payment step).
+    async function placeOrderInternal() {
+        const { selectedPaymentMethodId, locale } = get();
+        if (selectedPaymentMethodId == null) {
+            setError(makeError('validation', locale, 'payment'));
+            return;
+        }
+        setFlag('placingOrder', true);
+        setError(null);
+        try {
+            const created = await binding.client.payments.create(selectedPaymentMethodId);
+            if (created.error || !created.data) {
+                console.error('[Sazito Checkout] payments.create failed:', created.error);
+                const err = fromSdkError(created.error ?? { message: '', type: 'api' }, locale, 'result');
+                failResult(err.message, err);
+                return;
+            }
+            emit('payment_initiated', { step: 'payment', value: get().invoice?.finalTotal });
+            const action = await binding.client.payments.initialize();
+            if (action.error || !action.data) {
+                console.error('[Sazito Checkout] payments.initialize failed:', action.error);
+                const err = fromSdkError(action.error ?? { message: '', type: 'api' }, locale, 'result');
+                failResult(err.message, err);
+                return;
+            }
+            console.debug('[Sazito Checkout] payment init action:', action.data);
+            handlePaymentAction(action.data);
+        }
+        catch (e) {
+            // Network/unexpected throw — never leave the button spinning silently.
+            console.error('[Sazito Checkout] place order threw:', e);
+            const err = fromSdkError({ message: e?.message || '', type: 'network' }, locale, 'result');
+            failResult(err.message, err);
+        }
+        finally {
+            setFlag('placingOrder', false);
+        }
+    }
+    // Internal (lock-free) address submission shared by `submitAddress` & `next`.
+    async function submitAddressInternal() {
+        const state = get();
+        const submittedAddressRevision = addressRevision;
+        const needsShipping = state.invoice?.needsShipping ?? true;
+        const abandonStaleSubmission = (invoice) => {
+            set({
+                ...(invoice ? { invoice } : {}),
+                addressDirty: true,
+                applicable: null,
+                shippingGroups: []
+            });
+            setFlag('savingAddress', false);
+            return false;
+        };
+        if (!isAddressComplete(state.addressForm, needsShipping, state.postalCodeMandatory, state.emailMandatory)) {
+            setError(makeError('address_required', state.locale, 'shipping'));
+            return false;
+        }
+        // Skip the round-trip if nothing changed and shipping is already resolved.
+        if (!state.addressDirty && state.applicable && isShippingComplete(state.invoice, state.shippingGroups)) {
+            return true;
+        }
+        setFlag('savingAddress', true);
+        const input = toAddressInput(state.addressForm);
+        // Addresses attached to invoices are immutable order snapshots. Updating
+        // the previous address would also rewrite historical orders, so checkout
+        // always creates a new address and persists its new guest credentials.
+        const addrRes = await binding.client.shipping.createAddress(input);
+        if (addrRes.error || !addrRes.data) {
+            setFlag('savingAddress', false);
+            setError(fromSdkError(addrRes.error ?? { message: '', type: 'api' }, state.locale, 'shipping'));
+            return false;
+        }
+        if (addressRevision !== submittedAddressRevision) {
+            return abandonStaleSubmission();
+        }
+        const address = addrRes.data;
+        const linkRes = await binding.client.invoices.addShippingAddress(address.id, address.identifier);
+        if (linkRes.error || !linkRes.data) {
+            setFlag('savingAddress', false);
+            setError(fromSdkError(linkRes.error ?? { message: '', type: 'api' }, state.locale, 'shipping'));
+            return false;
+        }
+        if (addressRevision !== submittedAddressRevision) {
+            return abandonStaleSubmission(linkRes.data);
+        }
+        set({ invoice: linkRes.data, addressDirty: false });
+        if (needsShipping) {
+            const ok = await loadApplicableShipping(submittedAddressRevision);
+            if (ok) {
+                await assignCurrentShipping();
+                if (addressRevision !== submittedAddressRevision) {
+                    return abandonStaleSubmission();
+                }
+                await refreshInvoice();
+                if (addressRevision !== submittedAddressRevision) {
+                    return abandonStaleSubmission();
+                }
+            }
+            else if (addressRevision !== submittedAddressRevision) {
+                return abandonStaleSubmission();
+            }
+        }
+        setFlag('savingAddress', false);
+        emit('address_submitted', { step: 'shipping' });
+        return !get().error;
+    }
+    return {
+        getState: store.getState,
+        subscribe: store.subscribe,
+        actions,
+        setEffectExecutor(executor) {
+            effectExecutor = executor;
+        },
+        destroy() {
+            effectExecutor = noopEffectExecutor;
+        }
+    };
+}
+function readEmailMandatory(data) {
+    const root = asRecord(data);
+    const general = asRecord(root.general);
+    const generalInfo = asRecord(general.generalInfo ?? general.general_info ?? root.generalInfo ?? root.general_info);
+    const normalizedSettings = asRecord(root.settings);
+    const checkout = asRecord(generalInfo.checkout ?? root.checkout ?? normalizedSettings.checkout);
+    const optional = readCheckoutSettingBoolean(checkout.emailOptional ?? checkout.email_optional);
+    if (optional !== undefined)
+        return !optional;
+    return readCheckoutSettingBoolean(checkout.emailMandatory ?? checkout.email_mandatory);
+}
+function readPostalCodeMandatory(data) {
+    const root = asRecord(data);
+    const general = asRecord(root.general);
+    const generalInfo = asRecord(general.generalInfo ?? general.general_info ?? root.generalInfo ?? root.general_info);
+    const normalizedSettings = asRecord(root.settings);
+    const checkout = asRecord(generalInfo.checkout ?? root.checkout ?? normalizedSettings.checkout);
+    return readCheckoutSettingBoolean(checkout.postalCodeMandatory ?? checkout.postal_code_mandatory);
+}
+function asRecord(value) {
+    return value && typeof value === 'object'
+        ? value
+        : {};
+}
+function readCheckoutSettingBoolean(value) {
+    if (value && typeof value === 'object' && 'enabled' in value) {
+        return readCheckoutSettingBoolean(value.enabled);
+    }
+    if (value === true || value === 1 || value === '1' || value === 'true')
+        return true;
+    if (value === false || value === 0 || value === '0' || value === 'false')
+        return false;
+    return undefined;
+}
+function toAddressInput(form) {
+    return {
+        firstName: form.firstName.trim(),
+        lastName: form.lastName.trim(),
+        mobilePhone: form.mobilePhone.trim(),
+        email: form.email.trim() || undefined,
+        phoneNumber: form.phoneNumber.trim() || undefined,
+        regionId: form.regionId ?? undefined,
+        cityId: form.cityId ?? undefined,
+        address: form.address.trim(),
+        postalCode: form.postalCode.trim() || undefined,
+        description: form.description.trim() || undefined
+    };
+}
+/**
+ * Immediately derive updated invoice item quantities and totals from a fresh
+ * cart response so the summary panel doesn't wait for the invoice refresh.
+ */
+function applyCartToInvoice(invoice, cart) {
+    const byVariant = new Map(cart.items.map((i) => [i.productVariantId, i]));
+    const newItems = invoice.items
+        .filter((item) => byVariant.has(item.productVariantId))
+        .map((item) => {
+        const ci = byVariant.get(item.productVariantId);
+        return { ...item, quantity: ci.quantity, lineTotal: ci.lineTotal };
+    });
+    const subtotal = newItems.reduce((s, i) => s + i.lineTotal, 0);
+    const discount = (invoice.itemsDiscount || 0) + (invoice.discountTotal || 0) + (invoice.couponTotal || 0);
+    const finalTotal = Math.max(0, subtotal - discount + (invoice.shippingTotal || 0) + (invoice.vat || 0) - (invoice.creditTotal || 0));
+    return { ...invoice, items: newItems, itemsTotalRawPrice: subtotal, netTotal: subtotal, finalTotal };
+}
+// Map raw gateway-return query params into the typed payment-step input.
+// Only the string-valued callback fields are forwarded; `trackingData` /
+// `payload` are parsed from JSON when the gateway sends them encoded.
+function paymentReturnInput(params) {
+    if (!params || Object.keys(params).length === 0) {
+        return undefined;
+    }
+    const input = {};
+    if (params.tatoken != null)
+        input.tatoken = params.tatoken;
+    if (params.isFailed != null)
+        input.isFailed = params.isFailed;
+    if (params.code != null)
+        input.code = params.code;
+    if (params.imageUrl != null)
+        input.imageUrl = params.imageUrl;
+    if (params.id != null && Number.isFinite(Number(params.id)))
+        input.id = Number(params.id);
+    if (params.paymentIdentifier != null)
+        input.paymentIdentifier = params.paymentIdentifier;
+    const trackingData = parseJsonObject(params.trackingData);
+    if (trackingData)
+        input.trackingData = trackingData;
+    const payload = parseJsonObject(params.payload);
+    if (payload)
+        input.payload = payload;
+    return Object.keys(input).length > 0 ? input : undefined;
+}
+function parseJsonObject(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringifyFields(payload) {
+    const fields = {};
+    if (payload && typeof payload === 'object') {
+        for (const [key, value] of Object.entries(payload)) {
+            fields[key] = value == null ? '' : String(value);
+        }
+    }
+    return fields;
+}
+
+const FA_DIGITS = ['۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹'];
+function toPersianDigits(input) {
+    return input.replace(/\d/g, (d) => FA_DIGITS[Number(d)]);
+}
+function toEnglishDigits(input) {
+    return input.replace(/[۰-۹٠-٩]/g, (digit) => {
+        const code = digit.charCodeAt(0);
+        const value = code >= 0x06f0 ? code - 0x06f0 : code - 0x0660;
+        return String(value);
+    });
+}
+function formatNumber(value, locale) {
+    const grouped = Math.round(value || 0).toLocaleString('en-US');
+    return locale === 'fa' ? toPersianDigits(grouped) : grouped;
+}
+/**
+ * Format a percentage with up to `maxDecimals` digits, trimming trailing zeros.
+ * Keeps small fractions visible (e.g. 0.02%) where `formatNumber` would round to 0.
+ */
+function formatPercent(value, locale, maxDecimals = 2) {
+    const safe = value || 0;
+    const rounded = Number(safe.toFixed(maxDecimals));
+    const text = String(rounded);
+    return locale === 'fa' ? toPersianDigits(text) : text;
+}
+function defaultCurrencyLabel(locale) {
+    return locale === 'fa' ? 'تومان' : 'Toman';
+}
+function formatMoney(value, locale, currencyLabel) {
+    const label = currencyLabel ?? defaultCurrencyLabel(locale);
+    return `${formatNumber(value, locale)} ${label}`;
+}
+/**
+ * Normalize an Iranian phone number to the 11-digit 0XXXXXXXXXX format.
+ * Accepts: 09..., +989..., 00989..., 989..., 9... (10 digits without leading 0)
+ */
+function normalizeIranianPhone(raw) {
+    let s = toEnglishDigits(raw).replace(/[\s\-().]/g, '');
+    if (s.startsWith('+98'))
+        s = '0' + s.slice(3);
+    else if (s.startsWith('0098'))
+        s = '0' + s.slice(4);
+    else if (/^98\d{9}$/.test(s))
+        s = '0' + s.slice(2);
+    else if (/^9\d{9}$/.test(s))
+        s = '0' + s;
+    return s;
+}
+function isValidIranianPhone(s) {
+    return /^0[0-9]{10}$/.test(s);
+}
+function isValidIranianMobile(s) {
+    return /^09[0-9]{9}$/.test(s);
+}
+/** Free price shown when a rate / delivery costs nothing. */
+function formatPrice(value, locale, currencyLabel) {
+    if (!value || value <= 0) {
+        return locale === 'fa' ? 'رایگان' : 'Free';
+    }
+    return formatMoney(value, locale, currencyLabel);
+}
+
+const fa = {
+    stepCart: 'سبد خرید',
+    stepShipping: 'ارسال',
+    stepPayment: 'پرداخت',
+    stepReview: 'بازبینی',
+    stepResult: 'پایان خرید',
+    stepShippingInfo: 'اطلاعات ارسال',
+    stepOf: (current, total) => `مرحله ${current} از ${total}`,
+    next: 'ادامه',
+    placeOrder: 'ثبت سفارش',
+    saveShippingDetails: 'ثبت اطلاعات ارسال',
+    continueToPayment: 'ادامه به پرداخت',
+    finalizeOrder: 'نهایی‌سازی سفارش',
+    finishPurchase: 'پایان خرید',
+    back: 'بازگشت',
+    continueShopping: 'ادامه خرید',
+    orderSummary: 'خلاصه سفارش',
+    subtotal: 'جمع کل',
+    shipping: 'هزینه ارسال',
+    discount: 'تخفیف',
+    credit: 'اعتبار',
+    vat: 'مالیات',
+    total: 'مبلغ قابل پرداخت',
+    totalAmount: 'مبلغ کل',
+    free: 'رایگان',
+    quantity: 'تعداد',
+    optional: 'اختیاری',
+    cartTitle: 'سبد خرید شما',
+    cartEmpty: 'سبد خرید شما خالی است',
+    cartEmptyHint: 'محصولات موردعلاقه را اضافه کنید تا اینجا ببینید.',
+    remove: 'حذف',
+    itemDiscount: (amount) => `${amount} تخفیف`,
+    yourSavings: 'سود شما از این خرید',
+    contactInfo: 'اطلاعات تماس',
+    firstName: 'نام',
+    lastName: 'نام خانوادگی',
+    mobilePhone: 'شماره موبایل',
+    email: 'ایمیل',
+    phoneNumber: 'تلفن ثابت',
+    region: 'استان',
+    city: 'شهر',
+    postalCode: 'کد پستی',
+    addressLine: 'نشانی کامل',
+    description: 'توضیحات',
+    selectRegion: 'انتخاب استان',
+    selectCity: 'انتخاب شهر',
+    shippingMethod: 'روش ارسال',
+    shippingMethods: 'روش‌های ارسال',
+    shippingMethodsHint: 'پس از ثبت نشانی، روش‌های قابل استفاده نمایش داده می‌شوند.',
+    digitalNoShipping: 'محصول دیجیتال — بدون نیاز به ارسال',
+    errorRequired: 'این فیلد اجباری است',
+    errorMobilePhone: 'شماره موبایل معتبر وارد کنید (مثلاً ۰۹۱۲۳۴۵۶۷۸۹)',
+    errorEmail: 'آدرس ایمیل معتبر نیست',
+    changeTo: 'تغییر به',
+    productCount: (n) => `${n} محصول`,
+    paymentMethod: 'روش پرداخت',
+    discountCode: 'کد تخفیف',
+    discountPlaceholder: 'کد تخفیف را وارد کنید',
+    apply: 'اعمال',
+    applied: 'اعمال شد',
+    discountPercentOff: (percent) => `${percent}٪ تخفیف`,
+    discountAmountOff: (amount) => `${amount} تخفیف`,
+    discountFreeShipping: 'ارسال رایگان',
+    reviewTitle: 'بازبینی سفارش',
+    reviewContact: 'مشخصات گیرنده',
+    reviewAddress: 'آدرس ارسال',
+    reviewShipping: 'روش ارسال',
+    reviewPayment: 'روش پرداخت',
+    payNow: 'پرداخت',
+    edit: 'ویرایش',
+    paymentSuccess: 'پرداخت با موفقیت انجام شد',
+    paymentFailed: 'پرداخت ناموفق بود',
+    paymentPending: 'در حال بررسی پرداخت',
+    paymentPendingHint: 'پرداخت شما در حال پردازش است. لطفاً صبر کنید.',
+    orderNumber: 'شماره سفارش',
+    tryAgain: 'تلاش دوباره',
+    loading: 'در حال بارگذاری…',
+    processing: 'در حال پردازش…',
+    redirecting: 'در حال انتقال به درگاه پرداخت…'
+};
+const en = {
+    stepCart: 'Cart',
+    stepShipping: 'Shipping',
+    stepPayment: 'Payment',
+    stepReview: 'Review',
+    stepResult: 'Finish',
+    stepShippingInfo: 'Shipping details',
+    stepOf: (current, total) => `Step ${current} of ${total}`,
+    next: 'Continue',
+    placeOrder: 'Place order',
+    saveShippingDetails: 'Save shipping details',
+    continueToPayment: 'Continue to payment',
+    finalizeOrder: 'Finalize order',
+    finishPurchase: 'Finish purchase',
+    back: 'Back',
+    continueShopping: 'Continue shopping',
+    orderSummary: 'Order Summary',
+    subtotal: 'Subtotal',
+    shipping: 'Shipping',
+    discount: 'Discount',
+    credit: 'Credit',
+    vat: 'VAT',
+    total: 'Total',
+    totalAmount: 'Total amount',
+    free: 'Free',
+    quantity: 'Qty',
+    optional: 'Optional',
+    cartTitle: 'Your cart',
+    cartEmpty: 'Your cart is empty',
+    cartEmptyHint: 'Add a few items and they’ll show up here.',
+    remove: 'Remove',
+    itemDiscount: (amount) => `Save ${amount}`,
+    yourSavings: 'Your savings',
+    contactInfo: 'Contact information',
+    firstName: 'First name',
+    lastName: 'Last name',
+    mobilePhone: 'Mobile phone',
+    phoneNumber: 'Phone number',
+    email: 'Email',
+    region: 'Province',
+    city: 'City',
+    postalCode: 'Postal code',
+    addressLine: 'Full address',
+    description: 'Description',
+    selectRegion: 'Select province',
+    selectCity: 'Select city',
+    shippingMethod: 'Shipping method',
+    shippingMethods: 'Shipping methods',
+    shippingMethodsHint: 'Available delivery options will appear after you save this address.',
+    digitalNoShipping: 'Digital product — no shipping required',
+    errorRequired: 'This field is required',
+    errorMobilePhone: 'Enter a valid mobile number (e.g. 09123456789)',
+    errorEmail: 'Enter a valid email address',
+    changeTo: 'Switch to',
+    productCount: (n) => `${n} item(s)`,
+    paymentMethod: 'Payment method',
+    discountCode: 'Discount code',
+    discountPlaceholder: 'Enter discount code',
+    apply: 'Apply',
+    applied: 'Applied',
+    discountPercentOff: (percent) => `${percent}% off`,
+    discountAmountOff: (amount) => `${amount} off`,
+    discountFreeShipping: 'Free shipping',
+    reviewTitle: 'Review your order',
+    reviewContact: 'Recipient',
+    reviewAddress: 'Shipping address',
+    reviewShipping: 'Shipping method',
+    reviewPayment: 'Payment method',
+    payNow: 'Pay',
+    edit: 'Edit',
+    paymentSuccess: 'Payment completed successfully',
+    paymentFailed: 'Payment failed',
+    paymentPending: 'Verifying payment',
+    paymentPendingHint: 'Your payment is being processed. Please wait.',
+    orderNumber: 'Order number',
+    tryAgain: 'Try again',
+    loading: 'Loading…',
+    processing: 'Processing…',
+    redirecting: 'Redirecting to the payment gateway…'
+};
+const DICTS = { fa, en };
+function strings(locale) {
+    return DICTS[locale];
+}
+/** Brand/title + family per gateway. Unlisted codes fall back to a generic online gateway. */
+const GATEWAYS = {
+    cardtocardpayment: { kind: 'card', title: { fa: 'کارت به کارت', en: 'Card to card' } },
+    paymentinplace: { kind: 'cod', title: { fa: 'پرداخت در محل', en: 'Pay on delivery' } },
+    freepayment: { kind: 'free', title: { fa: 'پرداخت رایگان', en: 'Free' } },
+    // BNPL / installment
+    snapppayment: { kind: 'bnpl', title: { fa: 'اسنپ‌پی', en: 'SnappPay' } },
+    torobpaypayment: { kind: 'bnpl', title: { fa: 'ترب‌پی', en: 'TorobPay' } },
+    azkipayment: { kind: 'bnpl', title: { fa: 'ازکی‌وام', en: 'Azki' } },
+    digipaypayment: { kind: 'bnpl', title: { fa: 'دیجی‌پی', en: 'DigiPay' } },
+    tarapayment: { kind: 'bnpl', title: { fa: 'تارا', en: 'Tara' } },
+    tomanpayment: { kind: 'bnpl', title: { fa: 'تومان', en: 'Toman' } },
+    novapaypayment: { kind: 'bnpl', title: { fa: 'نوادپی', en: 'NovaPay' } },
+    // wallets
+    vandarpayment: { kind: 'wallet', title: { fa: 'کیف پول وندار', en: 'Vandar wallet' } },
+    zarinpalpayment: { kind: 'wallet', title: { fa: 'زرین‌پال', en: 'ZarinPal' } },
+    zarinpluspayment: { kind: 'wallet', title: { fa: 'زرین‌پلاس', en: 'ZarinPlus' } },
+    paypingpayment: { kind: 'wallet', title: { fa: 'پی‌پینگ', en: 'PayPing' } }
+};
+const KIND_DESC = {
+    card: { fa: 'انتقال مستقیم به شماره‌کارت فروشنده', en: 'Transfer directly to the seller’s card' },
+    cod: { fa: 'هنگام تحویل سفارش پرداخت کنید', en: 'Pay when your order is delivered' },
+    bnpl: { fa: 'خرید اعتباری و پرداخت اقساطی', en: 'Buy now, pay later in installments' },
+    wallet: { fa: 'پرداخت از موجودی کیف پول', en: 'Pay from your wallet balance' },
+    gateway: { fa: 'انتقال امن به درگاه بانکی', en: 'Secure redirect to the bank gateway' },
+    free: { fa: 'مبلغی برای پرداخت وجود ندارد', en: 'Nothing to pay for this order' }
+};
+const FALLBACK_TITLE = { fa: 'پرداخت آنلاین', en: 'Online payment' };
+/** Human label for a payment gateway code. Online gateways fall back generically. */
+function paymentMethodLabel(code, locale) {
+    return GATEWAYS[code]?.title[locale] ?? FALLBACK_TITLE[locale];
+}
+/** Title + description + visual family for a payment gateway code. */
+function paymentMethodInfo(code, locale) {
+    const meta = GATEWAYS[code];
+    const kind = meta?.kind ?? 'gateway';
+    return {
+        title: meta?.title[locale] ?? FALLBACK_TITLE[locale],
+        description: KIND_DESC[kind][locale],
+        kind
+    };
+}
+
+export { paymentMethodLabel as A, selectDigitalItems as B, selectSummary as C, strings as D, toEnglishDigits as E, toPersianDigits as F, addressFormFromInvoice as a, buildShippingAssignments as b, classifyAppliedDiscount as c, createBrowserEffectExecutor as d, createCheckoutEngine as e, createSdkBinding as f, createStore as g, defaultCurrencyLabel as h, deriveShippingGroups as i, emptyAddressForm as j, formatMoney as k, formatNumber as l, formatPercent as m, formatPrice as n, fromSdkError as o, isAddressComplete as p, isAddressDirty as q, isShippingComplete as r, isValidIranianMobile as s, isValidIranianPhone as t, makeError as u, makeEvent as v, messageForCode as w, noopEffectExecutor as x, normalizeIranianPhone as y, paymentMethodInfo as z };
+//# sourceMappingURL=labels-ChywPk2i.js.map