@aglyn/plugins-commerce 1.0.0-beta.232 → 1.0.0-beta.233

package/src/lib/server/local-fulfillment.js

@@ -0,0 +1,580 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { resolveSiteTimeZone } from "@aglyn/aglyn/app-utils/collection-entry-date";
+import { normalizePhone } from "@aglyn/aglyn/foundation/definitions/contact.types";
+import { pluginSmsMessaging } from "@aglyn/aglyn/plugin-manager/plugin-sms-messaging";
+import { pluginShippingRateQuoter } from "@aglyn/aglyn/plugin-manager/plugin-shipping-rates";
+import * as Aglyn from "@aglyn/aglyn/server";
+import { consumeRateLimit, firebaseAdmin, getOrgForHost } from "@aglyn/tenant-data-admin";
+import { isDocumentId } from "@aglyn/tenant-data-admin/server/document-id";
+import * as CommerceModel from "../model/index.js";
+import { readCartId } from "./cart-cookie.js";
+/** Reads the cart's declaration; `null` when it made none (a shipped order). */ export function readLocalFulfillmentRequest(value) {
+    if (!value || typeof value !== 'object') return null;
+    const raw = value;
+    const method = raw['method'];
+    if (method !== 'pickup' && method !== 'local_delivery') return null;
+    const text = (input, max)=>String(input != null ? input : '').trim().slice(0, max);
+    const request = {
+        method
+    };
+    const phone = normalizePhone(text(raw['textPhone'], 32));
+    if (phone) request.textPhone = phone;
+    if (method === 'pickup') {
+        request.locationId = text(raw['locationId'], 120);
+        return request;
+    }
+    const postalCode = text(raw['postalCode'], 16);
+    if (postalCode) request.postalCode = postalCode;
+    const start = Math.round(Number(raw['windowStartMs']));
+    if (Number.isFinite(start) && start > 0) request.windowStartMs = start;
+    const address = raw['address'];
+    if (address && typeof address === 'object') {
+        const parts = address;
+        request.address = {
+            line1: text(parts['line1'], 120),
+            line2: text(parts['line2'], 120),
+            city: text(parts['city'], 80),
+            state: text(parts['state'], 40),
+            postalCode: text(parts['postalCode'], 16) || postalCode
+        };
+    }
+    return request;
+}
+/** Reads what checkout and the cart need. Never throws: a failed read offers nothing. */ export async function readLocalFulfillmentStore(input) {
+    var _ref, _input_org;
+    const { hostRef } = input;
+    const [locationsSnapshot, settings, host] = await Promise.all([
+        hostRef.collection('locations').limit(CommerceModel.PICKUP_LOCATIONS_MAX).get().catch(()=>null),
+        input.storeSettings !== undefined ? Promise.resolve(input.storeSettings) : hostRef.collection('settings').doc('store').get().then((snapshot)=>{
+            var _ref;
+            var _snapshot_data;
+            return (_ref = snapshot == null ? void 0 : (_snapshot_data = snapshot.data) == null ? void 0 : _snapshot_data.call(snapshot)) != null ? _ref : null;
+        }).catch(()=>null),
+        input.host !== undefined ? Promise.resolve(input.host) : hostRef.get().then((snapshot)=>{
+            var _ref;
+            var _snapshot_data;
+            return (_ref = snapshot == null ? void 0 : (_snapshot_data = snapshot.data) == null ? void 0 : _snapshot_data.call(snapshot)) != null ? _ref : null;
+        }).catch(()=>null)
+    ]);
+    const locations = ((_ref = locationsSnapshot == null ? void 0 : locationsSnapshot.docs) != null ? _ref : []).map((snapshot)=>_extends({}, snapshot.data(), {
+            id: String(snapshot.id)
+        }));
+    return {
+        pickupLocations: CommerceModel.pickupLocationOptions(locations),
+        delivery: CommerceModel.normalizeLocalDeliverySettings(settings == null ? void 0 : settings['localDelivery']),
+        timeZone: resolveSiteTimeZone((_input_org = input.org) != null ? _input_org : null, host != null ? host : null)
+    };
+}
+/** How long checkout waits for an address to be placed on a map. */ export const LOCAL_DELIVERY_GEOCODE_TIMEOUT_MS = 3000;
+/**
+ * Places an address on the map through the shipping plugin's address check,
+ * or answers `null`: no plugin, not available on this site, no position in
+ * the answer, or slower than the timeout. Never throws.
+ */ export async function placeDeliveryAddress(hostId, address) {
+    if (!address.line1 || !address.postalCode) return null;
+    const quoter = pluginShippingRateQuoter();
+    if (!(quoter == null ? void 0 : quoter.validateAddress)) return null;
+    let timer;
+    try {
+        const placed = await Promise.race([
+            (async ()=>{
+                var _ref;
+                if (!await quoter.available(hostId)) return null;
+                const check = await (quoter.validateAddress == null ? void 0 : quoter.validateAddress.call(quoter, hostId, _extends({
+                    line1: address.line1
+                }, address.line2 ? {
+                    line2: address.line2
+                } : {}, address.city ? {
+                    city: address.city
+                } : {}, address.state ? {
+                    state: address.state
+                } : {}, {
+                    postalCode: address.postalCode,
+                    country: address.country
+                })));
+                return (check == null ? void 0 : check.verdict) === 'invalid' ? null : (_ref = check == null ? void 0 : check.coordinates) != null ? _ref : null;
+            })().catch(()=>null),
+            new Promise((resolve)=>{
+                timer = setTimeout(()=>resolve(null), LOCAL_DELIVERY_GEOCODE_TIMEOUT_MS);
+            })
+        ]);
+        return placed != null ? placed : null;
+    } finally{
+        if (timer) clearTimeout(timer);
+    }
+}
+/** The shipping option id a local delivery fee is declared under. */ export const LOCAL_DELIVERY_RATE_ID = 'local-delivery';
+const money = (cents)=>CommerceModel.formatOrderMoney(cents, 'USD');
+/**
+ * Turns the cart's declaration into what the session needs, or a refusal.
+ * Taken BEFORE any reservation or Stripe call, so a refusal costs nothing
+ * and the buyer's same button works once they choose again.
+ */ export async function planLocalFulfillment(input) {
+    var _input_nowMs, _request_postalCode;
+    var _request_address;
+    const { request, store } = input;
+    // A cart of downloads is not collected or driven anywhere.
+    if (!request || request.method === 'shipping' || !input.hasPhysicalLine) return {
+        kind: 'shipping'
+    };
+    const nowMs = (_input_nowMs = input.nowMs) != null ? _input_nowMs : Date.now();
+    if (request.method === 'pickup') {
+        const location = store.pickupLocations.find((entry)=>entry.id === request.locationId);
+        if (!location) {
+            return {
+                kind: 'refusal',
+                status: 409,
+                error: 'That pickup location is no longer available. Choose another.',
+                changed: 'pickup'
+            };
+        }
+        return {
+            kind: 'pickup',
+            location,
+            metadata: _extends({
+                fulfillment: 'pickup',
+                pickupLocationId: location.id
+            }, request.textPhone ? {
+                orderTextPhone: request.textPhone
+            } : {})
+        };
+    }
+    const delivery = store.delivery;
+    if (!CommerceModel.localDeliveryOffered(delivery)) {
+        return {
+            kind: 'refusal',
+            status: 409,
+            error: 'Local delivery is not available right now. Choose shipping or pickup.',
+            changed: 'delivery'
+        };
+    }
+    const country = String(delivery.country);
+    const postalCode = CommerceModel.normalizePostcode((_request_postalCode = request.postalCode) != null ? _request_postalCode : (_request_address = request.address) == null ? void 0 : _request_address.postalCode, country);
+    if (!postalCode) {
+        return {
+            kind: 'refusal',
+            status: 400,
+            error: 'Enter your postal code for delivery.'
+        };
+    }
+    let zone = CommerceModel.matchLocalDeliveryZone(delivery, {
+        country,
+        postalCode
+    });
+    if (!zone && CommerceModel.localDeliveryHasRadiusZones(delivery)) {
+        var _request_address1;
+        if (!((_request_address1 = request.address) == null ? void 0 : _request_address1.line1)) {
+            return {
+                kind: 'refusal',
+                status: 400,
+                error: 'Enter your street address for delivery.'
+            };
+        }
+        const coordinates = await placeDeliveryAddress(input.hostId, _extends({}, request.address, {
+            postalCode,
+            country
+        }));
+        zone = CommerceModel.matchLocalDeliveryZone(delivery, {
+            country,
+            postalCode,
+            coordinates
+        });
+    }
+    if (!zone) {
+        return {
+            kind: 'refusal',
+            status: 409,
+            error: `We don’t deliver to ${postalCode}. Choose shipping or pickup instead.`
+        };
+    }
+    const shortfall = CommerceModel.localDeliveryMinimumShortfall(zone, input.itemsCents);
+    if (shortfall > 0) {
+        var _zone_minimumCents;
+        return {
+            kind: 'refusal',
+            status: 409,
+            error: `Delivery to ${postalCode} needs an order of at least ${money((_zone_minimumCents = zone.minimumCents) != null ? _zone_minimumCents : 0)}. ` + `Add ${money(shortfall)} more, or choose shipping or pickup.`
+        };
+    }
+    const window = CommerceModel.findLocalDeliveryWindow(delivery, request.windowStartMs, {
+        nowMs,
+        timeZone: store.timeZone
+    });
+    if (!window) {
+        return {
+            kind: 'refusal',
+            status: 409,
+            error: 'That delivery time is no longer available. Choose another.',
+            changed: 'delivery'
+        };
+    }
+    const feeCents = CommerceModel.localDeliveryFeeCents(zone, input.itemsCents);
+    const label = CommerceModel.formatLocalDeliveryWindow(window, store.timeZone);
+    return _extends({
+        kind: 'local_delivery',
+        zone,
+        window,
+        feeCents,
+        country
+    }, delivery.locationId ? {
+        locationId: delivery.locationId
+    } : {}, {
+        option: {
+            rateId: LOCAL_DELIVERY_RATE_ID,
+            name: `Local delivery — ${label}`.slice(0, 100),
+            amountCents: feeCents
+        },
+        metadata: _extends({
+            fulfillment: 'local_delivery',
+            deliveryZoneId: zone.id,
+            deliveryWindowStartMs: String(window.startMs),
+            deliveryWindowEndMs: String(window.endMs),
+            deliveryPostalCode: postalCode,
+            deliveryFeeCents: String(feeCents)
+        }, delivery.locationId ? {
+            deliveryLocationId: delivery.locationId
+        } : {}, request.textPhone ? {
+            orderTextPhone: request.textPhone
+        } : {})
+    });
+}
+/** Sets a plan's metadata on a session's form body. */ export function appendLocalFulfillmentMetadata(params, metadata) {
+    for (const [key, value] of Object.entries(metadata)){
+        params.set(`metadata[${key}]`, String(value).slice(0, 480));
+    }
+}
+/** The location a plan takes its stock from, if any. */ export function localFulfillmentLocationId(plan) {
+    if (plan.kind === 'pickup') return plan.location.id;
+    if (plan.kind === 'local_delivery') return plan.locationId;
+    return undefined;
+}
+/** A stock refusal for a plan that reserves at one location (AGL-3624). */ export function localStockRefusalMessage(plan, productName) {
+    const what = productName ? `"${productName}"` : 'An item in your cart';
+    if (plan.kind === 'pickup') {
+        return `${what} is not in stock at ${plan.location.name}. Choose another location, or have it shipped.`;
+    }
+    return `${what} is not in stock for local delivery. Choose pickup at another location, or have it shipped.`;
+}
+/**
+ * Reads a paid session's `fulfillment` metadata into order fields, or `null`
+ * for a shipped order. The location and zone are re-read so the order keeps
+ * their names as they were when the buyer paid.
+ */ export async function orderLocalFulfillmentFromSession(input) {
+    var _input_metadata, _metadata_orderTextPhone, _ref, _metadata_deliveryZoneId, _store_delivery_zones, _metadata_deliveryPostalCode, _store_delivery_country, _ref1, _metadata_deliveryLocationId, _ref2, _store_delivery_instructions;
+    var _input_shippingAddress, _input_shippingAddress1;
+    const metadata = (_input_metadata = input.metadata) != null ? _input_metadata : {};
+    const method = metadata['fulfillment'];
+    if (method !== 'pickup' && method !== 'local_delivery') return null;
+    const textPhone = normalizePhone(String((_metadata_orderTextPhone = metadata['orderTextPhone']) != null ? _metadata_orderTextPhone : ''));
+    const phone = textPhone ? {
+        customerPhone: textPhone
+    } : {};
+    const org = await getOrgForHost(input.hostId).catch(()=>null);
+    const store = await readLocalFulfillmentStore({
+        hostRef: input.hostRef,
+        org: (_ref = org == null ? void 0 : org.org) != null ? _ref : null
+    });
+    if (method === 'pickup') {
+        var _metadata_pickupLocationId, _location_instructions;
+        const locationId = String((_metadata_pickupLocationId = metadata['pickupLocationId']) != null ? _metadata_pickupLocationId : '');
+        let location = store.pickupLocations.find((entry)=>entry.id === locationId);
+        // A location renamed or switched off after the buyer paid: the order
+        // still goes there, under the name the location doc now has.
+        if (!location && locationId) {
+            const snapshot = await input.hostRef.collection('locations').doc(locationId).get().catch(()=>null);
+            const data = (snapshot == null ? void 0 : snapshot.exists) ? snapshot.data() : null;
+            location = _extends({
+                id: locationId,
+                name: String((data == null ? void 0 : data.name) || 'the store')
+            }, data ? {
+                address: CommerceModel.formatPostalAddressLine(data.postalAddress, data.address) || undefined
+            } : {});
+        }
+        if (!location) return null;
+        const pickup = _extends({
+            locationId: location.id,
+            locationName: location.name
+        }, location.address ? {
+            address: location.address
+        } : {}, location.instructions ? {
+            instructions: location.instructions
+        } : {}, location.hours ? {
+            hours: location.hours
+        } : {}, {
+            status: 'preparing',
+            updatedAtMs: input.createdAtMs
+        });
+        const order = {
+            fulfillmentMethod: 'pickup',
+            pickup,
+            createdAtMs: input.createdAtMs
+        };
+        const list = CommerceModel.orderLocalFulfillmentListFields(order);
+        const ready = CommerceModel.pickupReadyWithinLabel(location.readyWithinMinutes);
+        return {
+            fields: _extends({
+                fulfillmentMethod: 'pickup',
+                pickup,
+                locationId: location.id
+            }, phone, list),
+            summary: [
+                `Pickup at ${location.name}${location.address ? `, ${location.address}` : ''}.`,
+                `We’ll let you know when it’s ready${ready ? ` (${ready.toLowerCase()})` : ''}.`,
+                (_location_instructions = location.instructions) != null ? _location_instructions : ''
+            ].filter(Boolean).join(' '),
+            outsideZone: false
+        };
+    }
+    const zoneId = String((_metadata_deliveryZoneId = metadata['deliveryZoneId']) != null ? _metadata_deliveryZoneId : '');
+    const zone = ((_store_delivery_zones = store.delivery.zones) != null ? _store_delivery_zones : []).find((entry)=>entry.id === zoneId);
+    const windowStartMs = Number(metadata['deliveryWindowStartMs']) || 0;
+    const windowEndMs = Number(metadata['deliveryWindowEndMs']) || windowStartMs;
+    const declared = String((_metadata_deliveryPostalCode = metadata['deliveryPostalCode']) != null ? _metadata_deliveryPostalCode : '');
+    const country = (_store_delivery_country = store.delivery.country) != null ? _store_delivery_country : String((_ref1 = (_input_shippingAddress = input.shippingAddress) == null ? void 0 : _input_shippingAddress.country) != null ? _ref1 : '');
+    const entered = CommerceModel.normalizePostcode((_input_shippingAddress1 = input.shippingAddress) == null ? void 0 : _input_shippingAddress1.postalCode, country);
+    // The fee was charged for the code the buyer declared. The address they
+    // then typed at payment must be in a zone too — a zone of ANY fee, since
+    // the store delivers there — or the store is told.
+    const outsideZone = Boolean(entered && entered !== declared && !CommerceModel.matchLocalDeliveryZone(store.delivery, {
+        country,
+        postalCode: entered
+    }));
+    const windowLabel = windowStartMs ? CommerceModel.formatLocalDeliveryWindow({
+        startMs: windowStartMs,
+        endMs: windowEndMs
+    }, store.timeZone) : '';
+    const locationId = String((_metadata_deliveryLocationId = metadata['deliveryLocationId']) != null ? _metadata_deliveryLocationId : '') || undefined;
+    const localDelivery = _extends({
+        zoneId,
+        zoneName: (_ref2 = zone == null ? void 0 : zone.name) != null ? _ref2 : 'Local delivery',
+        feeCents: Math.max(0, Math.round(Number(metadata['deliveryFeeCents']) || 0)),
+        windowStartMs,
+        windowEndMs
+    }, windowLabel ? {
+        windowLabel
+    } : {}, declared ? {
+        postalCode: declared
+    } : {}, locationId ? {
+        locationId
+    } : {}, {
+        status: 'scheduled'
+    }, outsideZone ? {
+        addressOutsideZone: true
+    } : {}, {
+        updatedAtMs: input.createdAtMs
+    });
+    const order = {
+        fulfillmentMethod: 'local_delivery',
+        localDelivery,
+        createdAtMs: input.createdAtMs
+    };
+    const list = CommerceModel.orderLocalFulfillmentListFields(order);
+    return {
+        fields: _extends({
+            fulfillmentMethod: 'local_delivery',
+            localDelivery
+        }, locationId ? {
+            locationId
+        } : {}, phone, list),
+        summary: [
+            `Local delivery${windowLabel ? `: ${windowLabel}` : ''}.`,
+            (_store_delivery_instructions = store.delivery.instructions) != null ? _store_delivery_instructions : ''
+        ].filter(Boolean).join(' '),
+        outsideZone
+    };
+}
+// ---------------------------------------------------------------------------
+// The cart's question: what can this basket be?
+// ---------------------------------------------------------------------------
+/** Distance zones place an address through a provider: a visitor may ask this often. */ const PLACE_LIMIT = {
+    limit: 20,
+    windowMs: 60 * 60 * 1000
+};
+/**
+ * `POST commerce/local-fulfillment-options` (AGL-3624): what the cart offers
+ * besides shipping — the pickup locations and, with a postal code, the
+ * delivery zone's fee, minimum and the windows open to book.
+ *
+ * Public, because a shopper asks it; it returns only what a storefront would
+ * print anyway (location names, addresses, hours, fees). It reads the
+ * visitor's own cart through the cart cookie and offers nothing for a
+ * basket with nothing physical in it.
+ */ export const localFulfillmentOptionsHandler = async (req, res)=>{
+    var _body_hostId;
+    if (req.method !== 'POST' && req.method !== 'GET') {
+        return res.status(405).json({
+            error: 'Method not allowed'
+        });
+    }
+    let body;
+    try {
+        var _req_body, _req_query;
+        body = req.method === 'POST' ? typeof req.body === 'string' ? JSON.parse(req.body || '{}') : (_req_body = req.body) != null ? _req_body : {} : (_req_query = req.query) != null ? _req_query : {};
+    } catch (unused) {
+        return res.status(400).json({
+            error: 'Invalid request'
+        });
+    }
+    const hostId = String((_body_hostId = body.hostId) != null ? _body_hostId : '');
+    if (!isDocumentId(hostId)) return res.status(400).json({
+        error: 'Missing or invalid hostId'
+    });
+    const nothing = {
+        pickup: [],
+        delivery: null
+    };
+    try {
+        var _cart_lines, _cart_lines1;
+        var _pluginSmsMessaging;
+        const firestore = firebaseAdmin.app().firestore();
+        const hostRef = firestore.collection('hosts').doc(hostId);
+        const ownerOrg = await getOrgForHost(hostId).catch(()=>null);
+        if (!(ownerOrg == null ? void 0 : ownerOrg.org) || !Aglyn.checkEntitlement(ownerOrg.org, 'commerce')) {
+            return res.status(200).json(nothing);
+        }
+        // The visitor's own basket decides whether there is anything to collect
+        // — or, from a product's Buy button, that one product (AGL-3624).
+        const buyNowProductId = typeof body.productId === 'string' ? body.productId : '';
+        let cart;
+        if (buyNowProductId) {
+            if (!isDocumentId(buyNowProductId)) return res.status(400).json({
+                error: 'Invalid productId'
+            });
+            cart = {
+                lines: [
+                    _extends({
+                        productId: buyNowProductId
+                    }, typeof body.variantId === 'string' && body.variantId ? {
+                        variantId: body.variantId
+                    } : {}, {
+                        quantity: Math.min(99, Math.max(1, Math.round(Number(body.quantity) || 1)))
+                    })
+                ]
+            };
+        } else {
+            var _ref;
+            var _cartSnapshot_data;
+            const cartId = readCartId(req.cookies, hostId);
+            const cartSnapshot = cartId ? await hostRef.collection('carts').doc(cartId).get().catch(()=>null) : null;
+            cart = (_ref = cartSnapshot == null ? void 0 : (_cartSnapshot_data = cartSnapshot.data) == null ? void 0 : _cartSnapshot_data.call(cartSnapshot)) != null ? _ref : {
+                lines: []
+            };
+        }
+        const productIds = [
+            ...new Set(((_cart_lines = cart.lines) != null ? _cart_lines : []).map((line)=>line.productId))
+        ].slice(0, 50);
+        const products = await Promise.all(productIds.map((id)=>hostRef.collection('products').doc(id).get().catch(()=>null)));
+        let itemsCents = 0;
+        let hasPhysicalLine = false;
+        for (const line of (_cart_lines1 = cart.lines) != null ? _cart_lines1 : []){
+            var _ref1, _product_type;
+            const snapshot = products[productIds.indexOf(line.productId)];
+            if (!(snapshot == null ? void 0 : snapshot.exists)) continue;
+            const product = CommerceModel.liftLegacyProduct(snapshot.data());
+            const variant = line.variantId ? product.variants.find((item)=>item.id === line.variantId) : product.variants[0];
+            itemsCents += Math.round(Number((_ref1 = variant == null ? void 0 : variant.priceUsd) != null ? _ref1 : 0) * 100) * (Number(line.quantity) || 0);
+            if (((_product_type = product.type) != null ? _product_type : 'physical') === 'physical') hasPhysicalLine = true;
+        }
+        if (!hasPhysicalLine) return res.status(200).json(nothing);
+        const store = await readLocalFulfillmentStore({
+            hostRef,
+            org: ownerOrg.org
+        });
+        const nowMs = Date.now();
+        let delivery = null;
+        if (CommerceModel.localDeliveryOffered(store.delivery)) {
+            var _ref2;
+            var _request_address;
+            const settings = store.delivery;
+            const country = String(settings.country);
+            const windows = CommerceModel.upcomingLocalDeliveryWindows(settings, {
+                nowMs,
+                timeZone: store.timeZone
+            }).map((window)=>_extends({}, window, {
+                    label: CommerceModel.formatLocalDeliveryWindow(window, store.timeZone)
+                }));
+            const radius = CommerceModel.localDeliveryHasRadiusZones(settings);
+            delivery = _extends({
+                country
+            }, settings.instructions ? {
+                instructions: settings.instructions
+            } : {}, {
+                needsAddress: radius,
+                windows
+            });
+            const request = readLocalFulfillmentRequest({
+                method: 'local_delivery',
+                postalCode: body.postalCode,
+                address: body.address
+            });
+            const postalCode = CommerceModel.normalizePostcode((_ref2 = request == null ? void 0 : request.postalCode) != null ? _ref2 : request == null ? void 0 : (_request_address = request.address) == null ? void 0 : _request_address.postalCode, country);
+            if (postalCode) {
+                var _request_address1;
+                let zone = CommerceModel.matchLocalDeliveryZone(settings, {
+                    country,
+                    postalCode
+                });
+                if (!zone && radius && (request == null ? void 0 : (_request_address1 = request.address) == null ? void 0 : _request_address1.line1)) {
+                    var _ref3;
+                    var _req_socket;
+                    const visitor = String((_ref3 = (_req_socket = req.socket) == null ? void 0 : _req_socket.remoteAddress) != null ? _ref3 : '') || 'no-address';
+                    const allowed = await consumeRateLimit(`local-delivery:place:${hostId}:${visitor}`, PLACE_LIMIT).then((result)=>result.allowed).catch(()=>false);
+                    const coordinates = allowed ? await placeDeliveryAddress(hostId, _extends({}, request.address, {
+                        postalCode,
+                        country
+                    })) : null;
+                    zone = CommerceModel.matchLocalDeliveryZone(settings, {
+                        country,
+                        postalCode,
+                        coordinates
+                    });
+                }
+                delivery['quote'] = zone ? _extends({
+                    zoneId: zone.id,
+                    zoneName: zone.name,
+                    feeCents: CommerceModel.localDeliveryFeeCents(zone, itemsCents)
+                }, zone.minimumCents ? {
+                    minimumCents: zone.minimumCents
+                } : {}, zone.freeOverCents ? {
+                    freeOverCents: zone.freeOverCents
+                } : {}, {
+                    shortfallCents: CommerceModel.localDeliveryMinimumShortfall(zone, itemsCents)
+                }) : {
+                    unavailable: `We don’t deliver to ${postalCode}.`
+                };
+            }
+        }
+        // Whether the cart may offer texts about the pickup or delivery: the
+        // platform can send them and the store has not turned them off.
+        const toggles = await hostRef.collection('settings').doc('store').get().then((snapshot)=>{
+            var _snapshot_get;
+            return snapshot == null ? void 0 : (_snapshot_get = snapshot.get) == null ? void 0 : _snapshot_get.call(snapshot, 'buyerNotifications');
+        }).catch(()=>null);
+        const texts = Boolean(((_pluginSmsMessaging = pluginSmsMessaging()) == null ? void 0 : _pluginSmsMessaging.isConfigured()) && CommerceModel.buyerNotificationEnabled(toggles, 'texts'));
+        return res.status(200).json({
+            pickup: store.pickupLocations,
+            delivery,
+            texts
+        });
+    } catch (error) {
+        console.error('[local-fulfillment] options failed', hostId, error);
+        return res.status(200).json(nothing);
+    }
+};
+
+//# sourceMappingURL=local-fulfillment.js.map