@salla.sa/twilight-components 3.0.17 → 3.0.19

package/dist/cjs/helpers-NV7wgP50.js

@@ -0,0 +1,602 @@
+/*!
+ * Crafted with ❤ by Salla
+ */
+'use strict';
+
+/**
+ * API Service for salla-bullet-delivery component
+ * Uses Salla's shipping API and scope API for delivery location management
+ */
+const API_LOG_PREFIX = 'BulletDeliveryAPI';
+const validId = (id) => {
+    const n = id == null ? Number.NaN : Number(id);
+    return !Number.isNaN(n) && n !== 0;
+};
+async function withApiErrorHandling(fn, fallback, logLabel) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        console.error(`${API_LOG_PREFIX}: ${logLabel}`, error);
+        return fallback;
+    }
+}
+const apiCache = new Map();
+const CACHE_TTL = 5 * 60 * 1000;
+let branchCacheGeneration = 0;
+const resolvedBranchPages = new WeakMap();
+function getCached(key) {
+    const entry = apiCache.get(key);
+    if (!entry || Date.now() - entry.timestamp > CACHE_TTL) {
+        apiCache.delete(key);
+        return null;
+    }
+    return entry.data;
+}
+function setCache(key, data) {
+    apiCache.set(key, { data, timestamp: Date.now() });
+}
+function getCountryBranches(branches, countryId) {
+    if (!branches || countryId == null)
+        return branches;
+    if (branches.some(branch => branch.country?.id == null))
+        return null;
+    const matches = branches.filter(branch => String(branch.country?.id) === String(countryId));
+    return matches.length ? matches : null;
+}
+function getBranchPage({ query, lat, lng, country_id, city_id, page, per_page = 20 }, cachePage = true) {
+    const params = { per_page };
+    if (query && query.trim().length >= 2)
+        params.query = query;
+    if (lat)
+        params.lat = Number(lat).toFixed(6);
+    if (lng)
+        params.lng = Number(lng).toFixed(6);
+    if (country_id)
+        params.country_id = country_id;
+    if (city_id)
+        params.city_id = city_id;
+    if (page && page > 1)
+        params.page = page;
+    const cacheKey = `branches_${JSON.stringify(params)}`;
+    const cached = cachePage ? getCached(cacheKey) : null;
+    if (cached)
+        return cached;
+    const request = (async () => {
+        const res = await salla.api.request('branches', { params });
+        if (!Array.isArray(res?.data))
+            throw new Error('Invalid branches response');
+        return { branches: res.data, perPage: per_page, pagination: res.pagination };
+    })();
+    if (cachePage)
+        setCache(cacheKey, request);
+    void request.then(page => { resolvedBranchPages.set(request, page); }, () => { });
+    void request.catch(() => {
+        if (apiCache.get(cacheKey)?.data === request)
+            apiCache.delete(cacheKey);
+    });
+    return request;
+}
+/** Uses country code from API (e.g. 'SA'). */
+const isSaudiArabia = (countryCode) => String(countryCode).toUpperCase() === 'SA';
+/**
+ * Fast Delivery API Service
+ * Uses Salla's shipping API and scopes API. Branch and address data are used as returned by the API (no mapping).
+ */
+const bulletDeliveryAPI = {
+    /**
+     * Get available countries from Salla shipping API
+     * @param forBranch - when true, use for_branch=1 (e.g. for pickup/branches tab)
+     */
+    async getCountries(forBranch = false, query) {
+        const cacheKey = !query?.trim() ? `countries_${forBranch ? 1 : 0}` : null;
+        if (cacheKey) {
+            const cached = getCached(cacheKey);
+            if (cached)
+                return cached;
+        }
+        const result = await withApiErrorHandling(async () => {
+            const params = { for_branch: forBranch ? 1 : 0 };
+            if (forBranch) {
+                params.for_allocation = 1;
+            }
+            if (query?.trim())
+                params.query = query.trim();
+            const data = (await salla.api.request("shipping/countries", { params }))?.data ?? [];
+            return data.map((c) => ({ id: c.id, code: c.code, name: c.name, has_regions: isSaudiArabia(c.code) }));
+        }, [], 'Error getting countries');
+        if (cacheKey && result.length > 0)
+            setCache(cacheKey, result);
+        return result;
+    },
+    /**
+     * Get regions for a country from Salla shipping API
+     * Endpoint: GET /shipping/countries/<COUNTRY_ID>/region
+     */
+    async getRegions(countryId, query) {
+        if (!validId(countryId)) {
+            console.warn(`${API_LOG_PREFIX}: getRegions called without valid country_id`);
+            return [];
+        }
+        const cacheKey = !query?.trim() ? `regions_${countryId}` : null;
+        if (cacheKey) {
+            const cached = getCached(cacheKey);
+            if (cached)
+                return cached;
+        }
+        const result = await withApiErrorHandling(async () => {
+            const params = {};
+            if (query?.trim())
+                params.query = query.trim();
+            const data = (await salla.api.request(`shipping/countries/${countryId}/regions`, { params }))?.data ?? [];
+            return data.map((r) => ({ id: r.id, name: r.name, code: r.code, country_id: Number(countryId) }));
+        }, [], 'Error fetching regions');
+        if (cacheKey && result.length > 0)
+            setCache(cacheKey, result);
+        return result;
+    },
+    /**
+     * Get cities from Salla shipping API
+     * @param regionId - Optional; when provided (e.g. for SA), cities are filtered by region
+     */
+    async getCities(countryId, regionId, query) {
+        if (!validId(countryId)) {
+            console.warn(`${API_LOG_PREFIX}: getCities called without valid country_id`);
+            return [];
+        }
+        const cacheKey = !query?.trim() ? `cities_${countryId}_${regionId || 'all'}` : null;
+        if (cacheKey) {
+            const cached = getCached(cacheKey);
+            if (cached)
+                return cached;
+        }
+        const result = await withApiErrorHandling(async () => {
+            const params = { for_branch: 0, country_id: countryId };
+            if (regionId)
+                params.region_id = regionId;
+            if (query?.trim())
+                params.query = query.trim();
+            const data = (await salla.api.request("shipping/cities", { params }))?.data ?? [];
+            return data.map((c) => ({ id: c.id, name: c.name, country_id: countryId, ...(c.region_id != null && { region_id: c.region_id }) }));
+        }, [], 'Error fetching cities');
+        if (cacheKey && result.length > 0)
+            setCache(cacheKey, result);
+        return result;
+    },
+    /**
+     * Get districts from Salla shipping API
+     */
+    async getDistricts(cityId, query) {
+        if (!validId(cityId)) {
+            console.warn(`${API_LOG_PREFIX}: getDistricts called without valid city_id`);
+            return [];
+        }
+        return withApiErrorHandling(async () => {
+            const params = { for_branch: 0, city_id: cityId };
+            if (query?.trim())
+                params.query = query.trim();
+            const raw = (await salla.api.request("shipping/districts", { params }))?.data;
+            const list = Array.isArray(raw) ? raw : (Array.isArray(raw?.districts) ? raw.districts : []);
+            return list.map((d) => ({ id: d.id, name: d.name, name_en: d.name_en, city_id: cityId }));
+        }, [], 'Error fetching districts');
+    },
+    async getSavedAddresses() {
+        return withApiErrorHandling(async () => {
+            const data = (await salla.api.request("address"))?.data;
+            return Array.isArray(data) ? data : [];
+        }, [], 'Error fetching user addresses');
+    },
+    /** Complete country rows for the city picker; incomplete reads remain retryable. */
+    async getAllBranches(country_id, per_page = 20) {
+        const collection = await this.getBranchCollection(country_id, per_page, { maxPages: Number.POSITIVE_INFINITY });
+        if (!collection.complete)
+            throw Object.assign(new Error('Incomplete branch city collection'), { branches: collection.branches });
+        return collection.branches;
+    },
+    /** Keeps loaded branches separate from whether the collection is complete. */
+    async getBranchCollection(country_id, per_page = 20, { maxPages = 10, requireComplete = false } = {}) {
+        const generation = branchCacheGeneration;
+        const cacheKey = `branches_all_${JSON.stringify([country_id ?? null, per_page, maxPages, requireComplete])}`;
+        const cached = Number.isFinite(maxPages) ? getCached(cacheKey) : null;
+        if (cached)
+            return cached;
+        const storeBranches = country_id != null ? getCached('branches_all') : null;
+        if (country_id == null)
+            setCache('branches_first', getBranchPage({ per_page, page: 1 }));
+        const partial = { branches: [], complete: false };
+        const request = withApiErrorHandling(async () => {
+            const sharedFirstPage = storeBranches ? getCached('branches_first') : null;
+            const first = sharedFirstPage ? resolvedBranchPages.get(sharedFirstPage) : null;
+            if (storeBranches && getCountryBranches(first?.branches ?? null, country_id)) {
+                const collection = await storeBranches;
+                if (generation !== branchCacheGeneration)
+                    return { branches: [], complete: false };
+                const branches = collection.complete ? getCountryBranches(collection.branches, country_id) : null;
+                if (branches)
+                    return { branches, complete: true };
+            }
+            for (let page = 1; page <= maxPages; page++) {
+                const { branches, pagination } = await getBranchPage({ country_id, per_page, page }, Number.isFinite(maxPages) || page === 1);
+                if (generation !== branchCacheGeneration)
+                    return { branches: [], complete: false };
+                const currentPage = Number(pagination?.currentPage ?? page);
+                const totalPages = Number(pagination?.totalPages);
+                if (page === 1 && totalPages === 0 && !branches.length)
+                    return { branches: [], complete: true };
+                if (pagination && (currentPage !== page || !Number.isInteger(totalPages) || totalPages < page)) {
+                    throw new Error('Invalid branches pagination');
+                }
+                partial.branches.push(...branches);
+                if (pagination) {
+                    if (requireComplete && totalPages > maxPages)
+                        return partial;
+                    if (page === totalPages)
+                        return { branches: partial.branches, complete: true };
+                    if (!branches.length)
+                        throw new Error('Incomplete branches response');
+                }
+                else if (branches.length < per_page) {
+                    return { branches: partial.branches, complete: true };
+                }
+            }
+            return partial;
+        }, partial, 'Error fetching all branches');
+        setCache(cacheKey, request);
+        if (country_id == null)
+            setCache('branches_all', request);
+        void request.then(collection => {
+            if (collection.complete) {
+                if (generation === branchCacheGeneration && apiCache.get('branches_all')?.data === request) {
+                    setCache('branches_complete', collection.branches);
+                }
+                return;
+            }
+            if (apiCache.get(cacheKey)?.data === request)
+                apiCache.delete(cacheKey);
+            if (apiCache.get('branches_all')?.data === request)
+                apiCache.delete('branches_all');
+        });
+        return request;
+    },
+    async getBranches(filters = {}) {
+        const generation = branchCacheGeneration;
+        const hasSearchParams = (filters.query && filters.query.trim().length >= 2) || filters.lat || filters.lng || filters.city_id;
+        const perPage = filters.per_page ?? 20;
+        const offset = ((filters.page ?? 1) - 1) * perPage;
+        if (!hasSearchParams) {
+            const branches = getCountryBranches(getCached('branches_complete'), filters.country_id);
+            if (branches) {
+                return branches.slice(offset, offset + perPage);
+            }
+            const firstPage = getCached('branches_first');
+            if (firstPage) {
+                const result = resolvedBranchPages.get(firstPage);
+                if (generation !== branchCacheGeneration)
+                    return [];
+                if (result) {
+                    const first = getCountryBranches(result.branches, filters.country_id);
+                    const complete = result.pagination
+                        ? Number(result.pagination.totalPages) === 1
+                        : result.branches.length < result.perPage;
+                    if (first && (first.length >= offset + perPage || complete)) {
+                        return first.slice(offset, offset + perPage);
+                    }
+                }
+            }
+        }
+        return withApiErrorHandling(async () => (await getBranchPage(filters)).branches, [], 'Error fetching branches');
+    },
+    async saveAddressLocation(payload) {
+        return withApiErrorHandling(async () => {
+            const res = await salla.api.request('address/location', { ...payload, for_allocation: true }, 'post');
+            const data = res?.data ?? res;
+            const address = typeof data === 'object' && data != null && 'id' in data ? data : undefined;
+            return { success: true, address };
+        }, { success: false }, 'Error saving address/location');
+    },
+    async setDeliveryScope(scopeId) {
+        return withApiErrorHandling(async () => {
+            await salla.api.withoutNotifier(() => salla.scope.change({ id: scopeId }));
+            salla.storage.set("scope", { ...(salla.storage.get("scope") || {}), id: scopeId });
+            return true;
+        }, false, 'Error setting delivery scope');
+    },
+    async allocateScope(payload) {
+        // A field reason (e.g. branch_id "not accepting orders") is more useful than the generic "invalid fields" message.
+        const errMsg = (d) => {
+            const body = d;
+            const fieldReason = Object.values(body?.error?.fields ?? {}).flat().find((m) => typeof m === 'string' && m.trim());
+            return fieldReason ?? body?.error?.message ?? body?.message ?? 'Failed to allocate scope';
+        };
+        try {
+            const response = await salla.api.withoutNotifier(() => salla.api.request("scopes/allocation", payload, 'post'));
+            // SDK resolves with { data } and throws on non-2xx; any resolved value is success
+            const data = response?.data ?? response;
+            return { success: true, data: data };
+        }
+        catch (error) {
+            console.error(`${API_LOG_PREFIX}: Error allocating scope`, error);
+            const err = error;
+            return { success: false, error: err?.response?.data != null ? errMsg(err.response.data) : (err?.message ?? 'Unknown error') };
+        }
+    },
+    async getAddressToken() {
+        return withApiErrorHandling(async () => {
+            const res = await salla.api.request('address/autocomplete-token');
+            return res?.data?.token ?? null;
+        }, null, 'Error fetching address autocomplete token');
+    },
+};
+function clearApiCache() {
+    branchCacheGeneration++;
+    apiCache.clear();
+}
+function clearBranchCache() {
+    branchCacheGeneration++;
+    for (const key of apiCache.keys()) {
+        if (key.startsWith('branches_'))
+            apiCache.delete(key);
+    }
+}
+
+/**
+ * Helper functions for salla-bullet-delivery component
+ */
+const EARTH_RADIUS_KM = 6371;
+const deg2rad = (deg) => deg * (Math.PI / 180);
+/** Haversine distance in km */
+function calculateDistance(lat1, lon1, lat2, lon2) {
+    const dLat = deg2rad(lat2 - lat1);
+    const dLon = deg2rad(lon2 - lon1);
+    const a = Math.sin(dLat / 2) ** 2 +
+        Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.sin(dLon / 2) ** 2;
+    return EARTH_RADIUS_KM * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+/**
+ * Whether a pickup branch can be selected.
+ *
+ * `pickup_readiness` is the richer, backend-computed verdict (INV-357) and wins whenever the API
+ * sends it. Not every store's `GET /branches` returns it though, so we fall back to the original
+ * `is_open` rule instead of treating a missing object as "not selectable" — otherwise every branch
+ * in the list renders disabled and pickup cannot be chosen at all (SP-22202).
+ */
+const isBranchSelectable = (branch) => {
+    if (!branch)
+        return false;
+    const selectable = branch.pickup_readiness?.selectable;
+    return typeof selectable === 'boolean' ? selectable : branch.is_open !== false;
+};
+/** Backend readiness label ("استلمه غدًا", "جاهز {date}") when pickup is not today; null otherwise. */
+const getBranchReadinessLabel = (branch) => {
+    const readiness = branch?.pickup_readiness;
+    return readiness?.label && ['tomorrow', 'later'].includes(readiness.state) ? readiness.label : null;
+};
+/** Branch-clock "HH:mm" a branch that is closed now becomes ready at later today; null otherwise. */
+const getBranchReadyTodayTime = (branch) => {
+    const readiness = branch?.pickup_readiness;
+    if (readiness?.state !== 'same_day' || branch?.is_open !== false)
+        return null;
+    return readiness.ready_at?.match(/T(\d{2}:\d{2})/)?.[1] ?? null;
+};
+/** Busy branches (stock at the merchant's stop-orders threshold) stay listed but dimmed and unselectable. */
+const isBranchBusy = (branch) => branch?.pickup_readiness?.state === 'orders_paused';
+/** Distinct cities of a branch list, in first-seen order (the API lists nearest first). */
+const getBranchCities = (branches) => {
+    const seen = new Set();
+    const cities = [];
+    for (const { city } of branches) {
+        if (!city?.id || seen.has(String(city.id)))
+            continue;
+        seen.add(String(city.id));
+        cities.push({ id: city.id, name: city.name });
+    }
+    return cities;
+};
+/** "3.52" / "12" — at most two decimals, as the checkout picker shows it; '' when the distance is unknown. */
+const formatBranchDistance = (km) => {
+    if (km == null || Number.isNaN(Number(km)))
+        return '';
+    return String(Math.round(Number(km) * 100) / 100);
+};
+/**
+ * Readiness states the picker hides outright instead of showing as a disabled card: closed and not
+ * taking pickup orders at all. Busy/out-of-stock stay visible-but-disabled so the shopper sees why
+ * (same rule as the checkout picker, INV-1414).
+ */
+const HIDDEN_READINESS_STATES = ['closed', 'unavailable'];
+const isBranchVisible = (branch) => !!branch && !HIDDEN_READINESS_STATES.includes(branch.pickup_readiness?.state);
+/** The branch's pickup offer (INV-1416); null when it has none, or a zero one, so "خصم 0%" never shows. */
+const getBranchDiscount = (branch) => {
+    const type = branch?.discount?.type;
+    const amount = Number(branch?.discount?.amount);
+    if ((type !== 'percentage' && type !== 'fixed_amount') || !(amount > 0))
+        return null;
+    return { type, amount };
+};
+/**
+ * Min–max pickup offer across the listed branches, for the pickup tab badge; null when none has one.
+ * Branches the picker hides are left out so the tab never advertises an offer the shopper can't pick.
+ * A percentage and a fixed amount can't share one range, so percentages win when both are set.
+ */
+const getBranchDiscountRange = (branches) => {
+    const discounts = branches.filter(isBranchVisible).map(getBranchDiscount).filter((d) => !!d);
+    if (!discounts.length)
+        return null;
+    const type = discounts.some(d => d.type === 'percentage') ? 'percentage' : 'fixed_amount';
+    const amounts = discounts.filter(d => d.type === type).map(d => d.amount);
+    return { type, min: Math.min(...amounts), max: Math.max(...amounts) };
+};
+/** The storefront's working_hours and ready_at use 24h "HH:mm"; null for anything else. */
+const parseBranchTime = (time) => {
+    const match = String(time ?? '').trim().match(/^(\d{1,2}):(\d{2})(?::\d{2})?$/);
+    if (!match || Number(match[1]) > 24)
+        return null;
+    return { hours: Number(match[1]) % 24, minutes: Number(match[2]) };
+};
+/** Date#getDay() keys for the day names the storefront API may send (Arabic or English). */
+const DAY_KEYS = {
+    sunday: 0, 'الاحد': 0,
+    monday: 1, 'الاثنين': 1,
+    tuesday: 2, 'الثلاثاء': 2,
+    wednesday: 3, 'الاربعاء': 3,
+    thursday: 4, 'الخميس': 4,
+    friday: 5, 'الجمعة': 5,
+    saturday: 6, 'السبت': 6,
+};
+const dayKeyFromName = (name) => DAY_KEYS[String(name ?? '').trim().toLowerCase().replace(/[أإآ]/g, 'ا')];
+/**
+ * The storefront's `working_hours` (`{ name, times: [{ from, to }] }`, 24h times) as weekly
+ * schedule rows for the hours dropdown.
+ */
+const getBranchWeekSchedule = (branch) => (branch.working_hours || [])
+    .filter(day => day?.name)
+    .map(day => ({
+    day_key: dayKeyFromName(day.name),
+    day: day.name,
+    times: (day.times || []).map(t => ({ start: t.from, end: t.to })),
+}));
+const isBranchAlwaysOpen = (branch) => !!branch.always_open;
+/**
+ * "11:00 م" / "11:00 PM". ar-SA's ICU pattern puts the day period first, which the bidi algorithm
+ * scrambles inside RTL text, so the parts are joined in a fixed "h:mm period" order instead.
+ */
+const formatBranchClockTime = (time, locale) => {
+    const parsed = parseBranchTime(time);
+    if (!parsed)
+        return '';
+    const date = new Date(Date.UTC(2000, 0, 1, parsed.hours, parsed.minutes));
+    const parts = new Intl.DateTimeFormat(locale === 'ar' ? 'ar-SA-u-nu-latn' : 'en', {
+        timeZone: 'UTC',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: true,
+    }).formatToParts(date);
+    const get = (type) => parts.find(p => p.type === type)?.value ?? '';
+    return `${get('hour')}:${get('minute')} ${get('dayPeriod')}`;
+};
+const sameTimes = (a, b) => a.length === b.length && a.every((t, i) => t.start === b[i].start && t.end === b[i].end);
+/** Consecutive days with identical hours collapse into one row; the largest groups come first. */
+const groupBranchSchedule = (weekSchedule) => {
+    const groups = [];
+    const days = [...(weekSchedule || [])].filter(s => s.times?.length).sort((a, b) => (a.day_key ?? 0) - (b.day_key ?? 0));
+    for (const day of days) {
+        const last = groups[groups.length - 1];
+        if (last && day.day_key === last.lastDayKey + 1 && sameTimes(last.times, day.times)) {
+            last.days.push(day.day);
+            last.lastDayKey = day.day_key;
+        }
+        else {
+            groups.push({ days: [day.day], times: day.times, lastDayKey: day.day_key ?? 0 });
+        }
+    }
+    return groups.sort((a, b) => b.days.length - a.days.length).map(({ days, times }) => ({ days, times }));
+};
+/** Keeps the digits and a leading "+" the merchant typed; drops spaces, dashes and brackets. */
+const cleanPhone = (value) => String(value ?? '').trim().replace(/[^\d+]/g, '');
+const getBranchPhoneHref = (branch) => {
+    const phone = cleanPhone(branch.contacts?.phone);
+    return phone ? `tel:${phone}` : null;
+};
+/** wa.me wants the international number as bare digits ("+966…" / "00966…" → "966…"). */
+const getBranchWhatsappHref = (branch) => {
+    const digits = cleanPhone(branch.contacts?.whatsapp).replace(/^\+/, '').replace(/^00/, '').replace(/\D/g, '');
+    return digits ? `https://wa.me/${digits}` : null;
+};
+const getBranchDirectionsHref = (branch) => branch.location?.lat != null && branch.location?.lng != null
+    ? `https://www.google.com/maps?q=${branch.location.lat},${branch.location.lng}`
+    : null;
+/** Nearest selectable branch by distance; single pass O(n). */
+function findNearestBranch(branches, userLat, userLon) {
+    let nearest = null;
+    let minD = Number.POSITIVE_INFINITY;
+    for (const b of branches) {
+        const lat = b.location?.lat != null ? Number(b.location.lat) : Number.NaN;
+        const lng = b.location?.lng != null ? Number(b.location.lng) : Number.NaN;
+        // Closed branches that still take orders are selectable too, so gate on selectability, not is_open.
+        if (Number.isNaN(lat) || Number.isNaN(lng) || !isBranchSelectable(b))
+            continue;
+        const d = calculateDistance(userLat, userLon, lat, lng);
+        if (d < minD) {
+            minD = d;
+            nearest = b;
+        }
+    }
+    return nearest;
+}
+/** Matches the fields the branches API searches: branch, city and country names (either language). */
+const filterBranches = (branches, searchQuery) => {
+    if (!searchQuery)
+        return branches;
+    const q = searchQuery.toLowerCase();
+    return branches.filter((b) => [b.name, b.city?.name, b.city?.name_en, b.country?.name, b.country?.name_en].some((name) => name?.toLowerCase().includes(q)));
+};
+const getIntentSubtitle = (intent, toAddress, fromBranch) => {
+    if (intent.type === 'branch') {
+        const loc = [intent.branch_details?.country, intent.branch_details?.city, intent.branch_details?.district].filter(Boolean).join('، ');
+        return loc ? `${fromBranch} ${loc}`.trim() : '';
+    }
+    if (intent.type === 'address' && intent.address_details) {
+        const addr = [intent.address_details.country?.name, intent.address_details.city?.name, intent.address_details.district?.name].filter(Boolean).join('، ') || intent.address_details.short_address || '';
+        return addr ? `${toAddress} ${addr}`.trim() : '';
+    }
+    return '';
+};
+const idFrom = (val) => (val != null ? Number(val) : undefined);
+const getIntentCountryId = (i) => idFrom(i?.address_details?.country?.id);
+const getIntentCountryCode = (i) => i?.country_code ?? i?.address_details?.country?.code ?? '';
+const getIntentRegionId = (i) => idFrom(i?.address_details?.region?.id);
+const getIntentCityId = (i) => idFrom(i?.address_details?.city?.id);
+const getIntentDistrictId = (i) => idFrom(i?.address_details?.district?.id);
+const getIntentBranchId = (i) => i?.branch_details?.id;
+const isMapOriginIntent = (i) => !!i && i.type === 'address' && i.address_details?.lat != null && i.address_details?.lng != null;
+const hasSessionAddressIntent = (intent) => {
+    if (!intent || intent.type !== 'address' || intent.address_id)
+        return false;
+    if (isMapOriginIntent(intent))
+        return true;
+    const c = getIntentCountryId(intent);
+    const city = getIntentCityId(intent);
+    const d = getIntentDistrictId(intent);
+    const code = getIntentCountryCode(intent);
+    const hasDistrictId = d != null && Number(d) !== 0;
+    const hasDistrictName = Boolean(intent.address_details?.district?.name?.trim());
+    const districtOk = !isSaudiArabia(code) || hasDistrictId || hasDistrictName;
+    return !!(c && city && districtOk);
+};
+const requireRegionAndDistrictForSA = (countryCode, regionId, districtIdOrName) => !countryCode || !isSaudiArabia(countryCode)
+    ? true
+    : (regionId != null && Number(regionId) !== 0) && (districtIdOrName != null && (typeof districtIdOrName === 'number' ? districtIdOrName !== 0 : String(districtIdOrName).trim().length > 0));
+
+exports.CACHE_TTL = CACHE_TTL;
+exports.bulletDeliveryAPI = bulletDeliveryAPI;
+exports.clearApiCache = clearApiCache;
+exports.clearBranchCache = clearBranchCache;
+exports.filterBranches = filterBranches;
+exports.findNearestBranch = findNearestBranch;
+exports.formatBranchClockTime = formatBranchClockTime;
+exports.formatBranchDistance = formatBranchDistance;
+exports.getBranchCities = getBranchCities;
+exports.getBranchDirectionsHref = getBranchDirectionsHref;
+exports.getBranchDiscount = getBranchDiscount;
+exports.getBranchDiscountRange = getBranchDiscountRange;
+exports.getBranchPhoneHref = getBranchPhoneHref;
+exports.getBranchReadinessLabel = getBranchReadinessLabel;
+exports.getBranchReadyTodayTime = getBranchReadyTodayTime;
+exports.getBranchWeekSchedule = getBranchWeekSchedule;
+exports.getBranchWhatsappHref = getBranchWhatsappHref;
+exports.getIntentBranchId = getIntentBranchId;
+exports.getIntentCityId = getIntentCityId;
+exports.getIntentCountryCode = getIntentCountryCode;
+exports.getIntentCountryId = getIntentCountryId;
+exports.getIntentDistrictId = getIntentDistrictId;
+exports.getIntentRegionId = getIntentRegionId;
+exports.getIntentSubtitle = getIntentSubtitle;
+exports.groupBranchSchedule = groupBranchSchedule;
+exports.hasSessionAddressIntent = hasSessionAddressIntent;
+exports.isBranchAlwaysOpen = isBranchAlwaysOpen;
+exports.isBranchBusy = isBranchBusy;
+exports.isBranchSelectable = isBranchSelectable;
+exports.isBranchVisible = isBranchVisible;
+exports.isMapOriginIntent = isMapOriginIntent;
+exports.isSaudiArabia = isSaudiArabia;
+exports.requireRegionAndDistrictForSA = requireRegionAndDistrictForSA;