@aglyn/plugins-commerce 1.0.0-beta.230 → 1.0.0-beta.231

package/src/lib/model/commerce-pos-ops.js

@@ -0,0 +1,721 @@
+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 { apportionCents } from "./commerce-orders.js";
+import { orderPayments } from "./commerce-pos.js";
+import { receiptDataFromOrder } from "./commerce-receipt.js";
+export const POS_TENDER_METHODS = [
+    'cash',
+    'card_present',
+    'card_keyed',
+    'card_link',
+    'gift_card',
+    'folio'
+];
+/** What each tender is called on a report, a receipt and a refund. */ export const POS_TENDER_LABELS = {
+    cash: 'Cash',
+    card_present: 'Card',
+    card_keyed: 'Card (keyed)',
+    card_link: 'Card (payment link)',
+    gift_card: 'Gift card',
+    folio: 'Room charge'
+};
+/** The tenders whose money moved through Stripe and goes back through it. */ export const POS_STRIPE_TENDERS = new Set([
+    'card_present',
+    'card_keyed',
+    'card_link'
+]);
+const wholeCents = (value)=>{
+    const number = Math.round(Number(value));
+    return Number.isFinite(number) && number > 0 ? number : 0;
+};
+const isTenderMethod = (value)=>typeof value === 'string' && POS_TENDER_METHODS.includes(value);
+/**
+ * THE ONE PLACE THE TENDER LEDGER IS READ (AGL-3609).
+ *
+ * A register sale may carry `payments[]` — one entry per tender, the ledger
+ * the split-tender register writes (AGL-3607) — and only the payments that
+ * SUCCEEDED count: a declined card or a voided gift card took nothing. An
+ * order written before that ledger is one payment, inferred the way the
+ * ledger's own reader infers it: a folio when it names a reservation, a card
+ * link when Stripe saw it (or it came through the storefront), cash otherwise.
+ *
+ * The ledger's own reader (`orderPayments`) does both; this narrows it to the
+ * settled payments and the fields a report or a refund reads.
+ */ export function posOrderTenders(order) {
+    if (!order) return [];
+    return orderPayments(order).filter((payment)=>payment.status === 'succeeded' && isTenderMethod(payment.method)).map((payment)=>{
+        var _payment_tipCents;
+        var _order_totals;
+        return _extends({
+            id: payment.id,
+            method: payment.method,
+            amountCents: wholeCents(payment.amountCents),
+            tipCents: wholeCents((_payment_tipCents = payment.tipCents) != null ? _payment_tipCents : payment.id === 'legacy' ? (_order_totals = order.totals) == null ? void 0 : _order_totals.tipCents : 0)
+        }, payment.paymentIntentId ? {
+            paymentIntentId: payment.paymentIntentId
+        } : {}, payment.giftCardId ? {
+            giftCardId: payment.giftCardId
+        } : {}, payment.reservationId ? {
+            reservationId: payment.reservationId
+        } : {}, payment.cardBrand ? {
+            cardBrand: payment.cardBrand
+        } : {}, payment.last4 ? {
+            last4: payment.last4
+        } : {}, payment.cashTenderedCents != null ? {
+            cashTenderedCents: wholeCents(payment.cashTenderedCents)
+        } : {}, payment.changeCents != null ? {
+            changeCents: wholeCents(payment.changeCents)
+        } : {});
+    });
+}
+/** A tender as one line of a receipt: `Card •• 4242`. */ export function posTenderLabel(tender) {
+    var _POS_TENDER_LABELS_tender_method;
+    const base = (_POS_TENDER_LABELS_tender_method = POS_TENDER_LABELS[tender.method]) != null ? _POS_TENDER_LABELS_tender_method : tender.method;
+    if (tender.last4) {
+        return `${tender.cardBrand ? capitalize(tender.cardBrand) : base} •• ${tender.last4}`;
+    }
+    return base;
+}
+function capitalize(value) {
+    return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;
+}
+export const POS_CASH_EVENT_LABELS = {
+    paid_in: 'Paid in',
+    paid_out: 'Paid out',
+    drop: 'Safe drop',
+    refund: 'Cash refund'
+};
+/** The cash-event sums one formula reads. */ export function posCashEventTotals(events) {
+    const sum = (type)=>(events != null ? events : []).filter((event)=>(event == null ? void 0 : event.type) === type).reduce((total, event)=>total + wholeCents(event.amountCents), 0);
+    return {
+        paidInCents: sum('paid_in'),
+        paidOutCents: sum('paid_out'),
+        dropsCents: sum('drop'),
+        cashRefundsCents: sum('refund')
+    };
+}
+/**
+ * THE DRAWER'S EXPECTED CASH: what should be in it when it is counted.
+ *
+ *   opening float + cash sales + paid in − paid out − safe drops − cash refunds
+ *
+ * Cash SALES are the cash tender's `amountCents`, which is what the sale took
+ * and never what the customer handed over: the change went straight back out
+ * of the same drawer. A tip left in cash is in the drawer too, so it counts.
+ */ export function posExpectedCashCents(input) {
+    return wholeCents(input.openingFloatCents) + wholeCents(input.cashSalesCents) + wholeCents(input.paidInCents) - wholeCents(input.paidOutCents) - wholeCents(input.dropsCents) - wholeCents(input.cashRefundsCents);
+}
+/**
+ * The X report (mid-shift) and the Z report (at close) are this one function
+ * over the sales stamped with the shift, the returns rung at the register
+ * during it and the shift's own cash events. A pending sale took no money and
+ * a cancelled one gave it back, so neither counts; a sale refunded LATER
+ * still counts as a sale, and its refund is counted where it was paid out.
+ */ export function computePosShiftReport(input) {
+    const salesByTender = {};
+    const refundsByTender = {};
+    let orderCount = 0;
+    let grossSalesCents = 0;
+    let discountsCents = 0;
+    let taxCents = 0;
+    let tipsCents = 0;
+    let cashSalesCents = 0;
+    for (const sale of input.sales){
+        var _ref;
+        var _sale_totals, _sale_totals1, _sale_totals2, _sale_totals3;
+        if (sale.status === 'pending' || sale.status === 'cancelled') continue;
+        const tenders = posOrderTenders(sale);
+        orderCount += 1;
+        grossSalesCents += wholeCents((_ref = (_sale_totals = sale.totals) == null ? void 0 : _sale_totals.totalCents) != null ? _ref : sale.amountCents);
+        discountsCents += wholeCents((_sale_totals1 = sale.totals) == null ? void 0 : _sale_totals1.discountCents);
+        taxCents += wholeCents((_sale_totals2 = sale.totals) == null ? void 0 : _sale_totals2.taxCents);
+        const tenderTips = tenders.reduce((sum, tender)=>sum + tender.tipCents, 0);
+        tipsCents += Math.max(wholeCents((_sale_totals3 = sale.totals) == null ? void 0 : _sale_totals3.tipCents), tenderTips);
+        for (const tender of tenders){
+            var _salesByTender_tender_method;
+            salesByTender[tender.method] = ((_salesByTender_tender_method = salesByTender[tender.method]) != null ? _salesByTender_tender_method : 0) + tender.amountCents;
+            if (tender.method === 'cash') cashSalesCents += tender.amountCents + tender.tipCents;
+        }
+    }
+    let refundsCents = 0;
+    for (const refund of input.refunds){
+        var _refund_tenders;
+        refundsCents += wholeCents(refund.refundedCents);
+        for (const tender of (_refund_tenders = refund.tenders) != null ? _refund_tenders : []){
+            var _refundsByTender_tender_method;
+            if (!isTenderMethod(tender.method)) continue;
+            refundsByTender[tender.method] = ((_refundsByTender_tender_method = refundsByTender[tender.method]) != null ? _refundsByTender_tender_method : 0) + wholeCents(tender.amountCents);
+        }
+    }
+    const cash = posCashEventTotals(input.shift.cashEvents);
+    const openingFloatCents = wholeCents(input.shift.openingFloatCents);
+    return _extends({
+        orderCount,
+        grossSalesCents,
+        discountsCents,
+        taxCents,
+        tipsCents,
+        salesByTender,
+        refundCount: input.refunds.length,
+        refundsCents,
+        refundsByTender,
+        netSalesCents: grossSalesCents - refundsCents,
+        openingFloatCents,
+        cashSalesCents
+    }, cash, {
+        expectedCashCents: posExpectedCashCents(_extends({
+            openingFloatCents,
+            cashSalesCents
+        }, cash))
+    }, input.truncated ? {
+        truncated: true
+    } : {});
+}
+/** counted − expected; positive is over, negative is short. */ export function posCashVarianceCents(countedCashCents, expectedCashCents) {
+    return Math.round(Number(countedCashCents) || 0) - Math.round(Number(expectedCashCents) || 0);
+}
+/** `$12.34`, `-$0.50` — the register's money format, store currency USD. */ export function posMoney(cents) {
+    const value = Math.round(Number(cents) || 0);
+    return `${value < 0 ? '-' : ''}$${(Math.abs(value) / 100).toFixed(2)}`;
+}
+/** One CSV cell, quoted when it needs to be and never read as a formula. */ function csvCell(value) {
+    let cell = value == null ? '' : String(value);
+    if (/^[=+\-@\t\r]/.test(cell) && !/^-?\d+(\.\d+)?$/.test(cell)) cell = `'${cell}`;
+    return /[",\r\n]/.test(cell) ? `"${cell.replace(/"/g, '""')}"` : cell;
+}
+const dollars = (cents)=>cents == null ? '' : (Math.round(cents) / 100).toFixed(2);
+/** The shift history as a spreadsheet: one row per shift, money in dollars. */ export function posShiftsCsv(shifts, memberName = (uid)=>uid) {
+    const header = [
+        'Shift',
+        'Register',
+        'Opened',
+        'Opened by',
+        'Closed',
+        'Closed by',
+        'Orders',
+        'Gross sales',
+        'Refunds',
+        'Net sales',
+        'Discounts',
+        'Tax',
+        'Tips',
+        'Cash sales',
+        'Card sales',
+        'Gift card sales',
+        'Room charges',
+        'Opening float',
+        'Paid in',
+        'Paid out',
+        'Safe drops',
+        'Cash refunds',
+        'Expected cash',
+        'Counted cash',
+        'Variance'
+    ];
+    const iso = (ms)=>ms ? new Date(ms).toISOString() : '';
+    const rows = shifts.map((shift)=>{
+        var _report_salesByTender_card_present, _report_salesByTender_card_keyed, _report_salesByTender_card_link, _shift_registerName, _shift_openedByName, _shift_closedByName, _ref, _report_salesByTender_gift_card, _report_salesByTender_folio, _shift_expectedCashCents;
+        const report = shift.report;
+        const card = report ? ((_report_salesByTender_card_present = report.salesByTender.card_present) != null ? _report_salesByTender_card_present : 0) + ((_report_salesByTender_card_keyed = report.salesByTender.card_keyed) != null ? _report_salesByTender_card_keyed : 0) + ((_report_salesByTender_card_link = report.salesByTender.card_link) != null ? _report_salesByTender_card_link : 0) : undefined;
+        return [
+            shift.id,
+            (_shift_registerName = shift.registerName) != null ? _shift_registerName : shift.registerId,
+            iso(shift.openedAtMs),
+            (_shift_openedByName = shift.openedByName) != null ? _shift_openedByName : memberName(shift.openedBy),
+            iso(shift.closedAtMs),
+            shift.closedBy ? (_shift_closedByName = shift.closedByName) != null ? _shift_closedByName : memberName(shift.closedBy) : '',
+            (_ref = report == null ? void 0 : report.orderCount) != null ? _ref : '',
+            dollars(report == null ? void 0 : report.grossSalesCents),
+            dollars(report == null ? void 0 : report.refundsCents),
+            dollars(report == null ? void 0 : report.netSalesCents),
+            dollars(report == null ? void 0 : report.discountsCents),
+            dollars(report == null ? void 0 : report.taxCents),
+            dollars(report == null ? void 0 : report.tipsCents),
+            dollars(report == null ? void 0 : report.cashSalesCents),
+            dollars(card),
+            dollars(report ? (_report_salesByTender_gift_card = report.salesByTender.gift_card) != null ? _report_salesByTender_gift_card : 0 : undefined),
+            dollars(report ? (_report_salesByTender_folio = report.salesByTender.folio) != null ? _report_salesByTender_folio : 0 : undefined),
+            dollars(shift.openingFloatCents),
+            dollars(report == null ? void 0 : report.paidInCents),
+            dollars(report == null ? void 0 : report.paidOutCents),
+            dollars(report == null ? void 0 : report.dropsCents),
+            dollars(report == null ? void 0 : report.cashRefundsCents),
+            dollars((_shift_expectedCashCents = shift.expectedCashCents) != null ? _shift_expectedCashCents : report == null ? void 0 : report.expectedCashCents),
+            dollars(shift.countedCashCents),
+            dollars(shift.varianceCents)
+        ];
+    });
+    return [
+        header,
+        ...rows
+    ].map((row)=>row.map(csvCell).join(',')).join('\r\n');
+}
+/**
+ * What each line is worth back, whole: its price less its share of the
+ * order's discount, plus its share of the order's tax — the same
+ * apportionment `orderLineRefundCents` uses for the discount, extended to the
+ * tax a register sale charged on top. Shipping and tips are not a line's.
+ */ export function posReturnLineValues(order) {
+    var _order_lineItems;
+    var _order_totals, _order_totals1;
+    const lines = (_order_lineItems = order.lineItems) != null ? _order_lineItems : [];
+    const gross = lines.map((line)=>{
+        var _ref, _ref1;
+        return Math.max(0, Math.round(Number((_ref = line == null ? void 0 : line.unitAmountCents) != null ? _ref : 0))) * Math.max(1, Math.round(Number((_ref1 = line == null ? void 0 : line.quantity) != null ? _ref1 : 1)));
+    });
+    const discountShares = apportionCents(gross, wholeCents((_order_totals = order.totals) == null ? void 0 : _order_totals.discountCents));
+    const net = gross.map((cents, index)=>{
+        var _discountShares_index;
+        return Math.max(0, cents - ((_discountShares_index = discountShares[index]) != null ? _discountShares_index : 0));
+    });
+    const taxShares = apportionCents(net, wholeCents((_order_totals1 = order.totals) == null ? void 0 : _order_totals1.taxCents));
+    return net.map((cents, index)=>{
+        var _taxShares_index;
+        return cents + ((_taxShares_index = taxShares[index]) != null ? _taxShares_index : 0);
+    });
+}
+/** Units of each line already returned, a line refunded whole counting as all of it. */ export function posReturnedQuantities(order) {
+    var _order_lineItems, _order_refundedLineItemIds;
+    const lines = (_order_lineItems = order.lineItems) != null ? _order_lineItems : [];
+    const wholeLines = new Set((_order_refundedLineItemIds = order.refundedLineItemIds) != null ? _order_refundedLineItemIds : []);
+    return lines.map((line, index)=>{
+        var _ref, _ref1;
+        var _order_returnedQuantities;
+        const quantity = Math.max(1, Math.round(Number((_ref = line == null ? void 0 : line.quantity) != null ? _ref : 1)));
+        if (wholeLines.has(index)) return quantity;
+        const returned = Math.round(Number((_ref1 = (_order_returnedQuantities = order.returnedQuantities) == null ? void 0 : _order_returnedQuantities[String(index)]) != null ? _ref1 : 0));
+        return Math.min(quantity, Math.max(0, Number.isFinite(returned) ? returned : 0));
+    });
+}
+/**
+ * What a return of these picks refunds, to the cent.
+ *
+ * Each line's value is split across its units CUMULATIVELY: returning `k` of
+ * `n` units already returned `r` refunds `round(V·(r+k)/n) − round(V·r/n)`,
+ * so returning a line one unit at a time refunds exactly what returning it
+ * whole would have, and the rounding never strands or invents a cent. The
+ * sum is capped at what is left to refund on the order — a refund given
+ * from the order dialog already took its share.
+ *
+ * `heldElsewhere` is, per line, the units an online return (the returns
+ * flow) already holds or took back. They cap what the register may take, but
+ * they are not written into `returnedQuantities`, which counts only what the
+ * register itself took.
+ */ export function planPosReturn(order, picks, heldElsewhere = []) {
+    var _order_lineItems;
+    var _order_totals;
+    const lines = (_order_lineItems = order.lineItems) != null ? _order_lineItems : [];
+    if (!picks.length) return {
+        ok: false,
+        error: 'Pick at least one item to return.'
+    };
+    const values = posReturnLineValues(order);
+    const returned = posReturnedQuantities(order);
+    const seen = new Set();
+    const lineCents = [];
+    const nextReturned = {};
+    for (const [index, count] of returned.entries())if (count > 0) nextReturned[String(index)] = count;
+    const completedLines = [];
+    for (const pick of picks){
+        var _ref, _returned_index, _heldElsewhere_index, _values_index;
+        var _lines_index;
+        const index = Number(pick.index);
+        const quantity = Number(pick.quantity);
+        if (!Number.isInteger(index) || index < 0 || index >= lines.length) {
+            return {
+                ok: false,
+                error: `Line ${pick.index} is not on this order.`
+            };
+        }
+        if (seen.has(index)) return {
+            ok: false,
+            error: 'Each line can be picked once.'
+        };
+        seen.add(index);
+        if (!Number.isInteger(quantity) || quantity < 1) {
+            return {
+                ok: false,
+                error: 'Return at least one of each line you pick.'
+            };
+        }
+        const total = Math.max(1, Math.round(Number((_ref = (_lines_index = lines[index]) == null ? void 0 : _lines_index.quantity) != null ? _ref : 1)));
+        const already = (_returned_index = returned[index]) != null ? _returned_index : 0;
+        const held = Math.max(0, Math.round(Number((_heldElsewhere_index = heldElsewhere[index]) != null ? _heldElsewhere_index : 0)));
+        if (already + held + quantity > total) {
+            var _ref1, _ref2, _ref3;
+            var _lines_index1, _lines_index2, _lines_index3;
+            const left = Math.max(0, total - already - held);
+            return {
+                ok: false,
+                error: left > 0 ? `Only ${left} of "${(_ref1 = (_lines_index1 = lines[index]) == null ? void 0 : _lines_index1.name) != null ? _ref1 : 'that item'}" can still be returned.` : held > 0 ? `"${(_ref2 = (_lines_index2 = lines[index]) == null ? void 0 : _lines_index2.name) != null ? _ref2 : 'That item'}" is already in a return. Finish it under Returns.` : `"${(_ref3 = (_lines_index3 = lines[index]) == null ? void 0 : _lines_index3.name) != null ? _ref3 : 'That item'}" has already been returned.`
+            };
+        }
+        const value = (_values_index = values[index]) != null ? _values_index : 0;
+        lineCents.push(Math.round(value * (already + quantity) / total) - Math.round(value * already / total));
+        nextReturned[String(index)] = already + quantity;
+        if (already + quantity === total) completedLines.push(index);
+    }
+    const remaining = Math.max(0, wholeCents((_order_totals = order.totals) == null ? void 0 : _order_totals.totalCents) - wholeCents(order.refundedCents));
+    const asked = lineCents.reduce((sum, cents)=>sum + cents, 0);
+    const refundCents = Math.min(asked, remaining);
+    if (!(refundCents > 0)) return {
+        ok: false,
+        error: 'Nothing is left to refund on this order.'
+    };
+    return {
+        ok: true,
+        refundCents,
+        lineCents,
+        returnedQuantities: nextReturned,
+        completedLines
+    };
+}
+/**
+ * What each payment can still take back: what it put toward the sale, less
+ * what register returns already sent to it. A refund given from the order
+ * dialog refunds through Stripe without naming a payment, so whatever it
+ * took that no payment accounts for comes off the Stripe payments first.
+ */ export function posRefundableByTender(order) {
+    var _order_posPaymentRefunds;
+    const tenders = posOrderTenders(order);
+    const attributed = Object.values((_order_posPaymentRefunds = order.posPaymentRefunds) != null ? _order_posPaymentRefunds : {}).reduce((sum, cents)=>sum + wholeCents(cents), 0);
+    let unattributed = Math.max(0, wholeCents(order.refundedCents) - attributed);
+    const ordered = [
+        ...tenders
+    ].sort((a, b)=>Number(POS_STRIPE_TENDERS.has(b.method)) - Number(POS_STRIPE_TENDERS.has(a.method)));
+    const refundable = new Map();
+    for (const tender of ordered){
+        var _order_posPaymentRefunds1;
+        let left = Math.max(0, tender.amountCents - wholeCents((_order_posPaymentRefunds1 = order.posPaymentRefunds) == null ? void 0 : _order_posPaymentRefunds1[tender.id]));
+        if (POS_STRIPE_TENDERS.has(tender.method) && unattributed > 0) {
+            const taken = Math.min(left, unattributed);
+            left -= taken;
+            unattributed -= taken;
+        }
+        refundable.set(tender.id, left);
+    }
+    return tenders.map((tender)=>{
+        var _refundable_get;
+        return _extends({}, tender, {
+            refundableCents: (_refundable_get = refundable.get(tender.id)) != null ? _refundable_get : 0
+        });
+    });
+}
+/**
+ * The order a refund goes back in, when the cashier does not split it by
+ * hand: the cards first, then store credit, then the room, and the drawer
+ * LAST — so cash leaves the till only for what the customer paid in cash.
+ */ const REFUND_ORDER = [
+    'card_present',
+    'card_keyed',
+    'card_link',
+    'gift_card',
+    'folio',
+    'cash'
+];
+/**
+ * Sends `amountCents` back to the sale's own payments.
+ *
+ * With no `requested` split, each payment takes what it can in
+ * {@link REFUND_ORDER}. With one, every slice must name a payment of this
+ * sale and fit what that payment can still take, and the slices must add up
+ * to the refund exactly — a refund is never sent to a tender the sale was
+ * not paid with.
+ */ export function splitPosRefund(order, amountCents, requested) {
+    const amount = wholeCents(amountCents);
+    const tenders = posRefundableByTender(order);
+    if (!tenders.length) return {
+        ok: false,
+        error: 'This order has no payment to refund to.'
+    };
+    if (requested && requested.length) {
+        const allocations = [];
+        const used = new Set();
+        for (const slice of requested){
+            const tender = tenders.find((candidate)=>candidate.id === slice.paymentId);
+            if (!tender) return {
+                ok: false,
+                error: 'That payment is not on this order.'
+            };
+            if (used.has(tender.id)) return {
+                ok: false,
+                error: 'Each payment can be named once.'
+            };
+            used.add(tender.id);
+            const cents = Math.round(Number(slice.amountCents));
+            if (!Number.isFinite(cents) || cents < 0) return {
+                ok: false,
+                error: 'Refund amounts must be positive.'
+            };
+            if (cents === 0) continue;
+            if (cents > tender.refundableCents) {
+                return {
+                    ok: false,
+                    error: `${posTenderLabel(tender)} can take back at most ${posMoney(tender.refundableCents)}.`
+                };
+            }
+            allocations.push({
+                paymentId: tender.id,
+                method: tender.method,
+                amountCents: cents
+            });
+        }
+        const total = allocations.reduce((sum, slice)=>sum + slice.amountCents, 0);
+        if (total !== amount) {
+            return {
+                ok: false,
+                error: `The refund is ${posMoney(amount)}; the split adds up to ${posMoney(total)}.`
+            };
+        }
+        return {
+            ok: true,
+            allocations
+        };
+    }
+    const ordered = [
+        ...tenders
+    ].sort((a, b)=>REFUND_ORDER.indexOf(a.method) - REFUND_ORDER.indexOf(b.method));
+    const allocations = [];
+    let left = amount;
+    for (const tender of ordered){
+        if (!(left > 0)) break;
+        const cents = Math.min(left, tender.refundableCents);
+        if (!(cents > 0)) continue;
+        allocations.push({
+            paymentId: tender.id,
+            method: tender.method,
+            amountCents: cents
+        });
+        left -= cents;
+    }
+    if (left > 0) {
+        return {
+            ok: false,
+            error: `Only ${posMoney(amount - left)} can go back to this sale's payments.`
+        };
+    }
+    return {
+        ok: true,
+        allocations
+    };
+}
+/*==========================================
+ * STAFF PINS
+ *=========================================*/ /** How long a cashier PIN switch lasts before the register asks again. */ export const POS_CASHIER_ASSERTION_TTL_MS = 15 * 60 * 1000;
+/** A manager's approval is for the one refund in front of them. */ export const POS_MANAGER_ASSERTION_TTL_MS = 2 * 60 * 1000;
+/** Wrong PINs in a row before the member is locked out. */ export const POS_PIN_MAX_ATTEMPTS = 5;
+/** How long a lockout lasts. */ export const POS_PIN_LOCKOUT_MS = 15 * 60 * 1000;
+/**
+ * Why a PIN cannot be used, or `null` when it can: 4 to 6 digits, and not
+ * one a stranger tries first — every digit the same, or a straight run.
+ */ export function posPinProblem(pin) {
+    var _digits_, _digits_1;
+    const value = typeof pin === 'string' ? pin : '';
+    if (!/^\d{4,6}$/.test(value)) return 'A PIN is 4 to 6 digits.';
+    if (/^(\d)\1+$/.test(value)) return 'Pick a PIN that is not one digit repeated.';
+    const digits = [
+        ...value
+    ].map(Number);
+    const step = ((_digits_ = digits[1]) != null ? _digits_ : 0) - ((_digits_1 = digits[0]) != null ? _digits_1 : 0);
+    if ((step === 1 || step === -1) && digits.every((digit, index)=>{
+        var _digits_;
+        return index === 0 || digit - ((_digits_ = digits[index - 1]) != null ? _digits_ : 0) === step;
+    })) {
+        return 'Pick a PIN that is not a straight run like 1234.';
+    }
+    return null;
+}
+/**
+ * The receipt for one sale, from the order alone plus what the store prints
+ * on every receipt. The sale's lines, totals, tenders and change are the
+ * receipt model's (`receiptDataFromOrder`, the one the cloud printers print
+ * from), so a browser print and a cloud print never disagree; this adds the
+ * logo, the address, the return policy and the gift receipt. A gift receipt
+ * keeps the lines and the barcode — the recipient's way to return — and
+ * drops every price, total and tender.
+ */ export function buildPosReceipt(input) {
+    var _input_formatDate, _input_store_address, _data_tenders;
+    const { order } = input;
+    const gift = input.gift === true;
+    const data = receiptDataFromOrder(input.orderId, order, {
+        storeName: input.store.name
+    });
+    const lines = data.lines.map((line)=>_extends({
+            name: line.name
+        }, line.detail ? {
+            variantLabel: line.detail
+        } : {}, {
+            quantity: line.quantity,
+            unitAmountCents: gift ? 0 : line.unitCents,
+            lineCents: gift ? 0 : line.totalCents
+        }));
+    const number = Number(order.number);
+    const digits = Number.isInteger(number) && number > 0 ? String(number) : '';
+    const createdAtMs = Number(order.createdAtMs) || 0;
+    const formatDate = (_input_formatDate = input.formatDate) != null ? _input_formatDate : (ms)=>ms ? new Date(ms).toLocaleString() : '';
+    const money = (cents)=>gift ? 0 : wholeCents(cents);
+    return _extends({
+        storeName: input.store.name
+    }, input.store.logoUrl ? {
+        logoUrl: input.store.logoUrl
+    } : {}, {
+        addressLines: String((_input_store_address = input.store.address) != null ? _input_store_address : '').split(/\r?\n/).map((line)=>line.trim()).filter(Boolean),
+        orderNumber: digits ? `#${digits}` : `#${input.orderId.slice(0, 8)}`,
+        barcodeValue: digits || input.orderId,
+        dateLabel: formatDate(createdAtMs)
+    }, input.cashierName ? {
+        cashierName: input.cashierName
+    } : {}, input.registerName ? {
+        registerName: input.registerName
+    } : {}, order.customerName ? {
+        customerName: String(order.customerName)
+    } : {}, {
+        lines,
+        subtotalCents: money(data.subtotalCents),
+        discountCents: money(data.discountCents),
+        taxCents: money(data.taxCents),
+        totalCents: money(data.totalCents),
+        tipCents: money(data.tipCents),
+        tenders: gift ? [] : (_data_tenders = data.tenders) != null ? _data_tenders : [],
+        changeCents: money(data.changeCents),
+        refundedCents: money(data.refundedCents)
+    }, input.store.footer ? {
+        footer: input.store.footer
+    } : {}, input.store.returnPolicy ? {
+        returnPolicy: input.store.returnPolicy
+    } : {}, {
+        gift
+    });
+}
+/** The rows of an X or Z report, in the order a manager reads them. */ export function posShiftReportRows(report, shift) {
+    var _shift_varianceCents, _shift_varianceCents1, _shift_varianceCents2;
+    const tenders = POS_TENDER_METHODS.filter((method)=>{
+        var _report_salesByTender_method, _report_refundsByTender_method;
+        return ((_report_salesByTender_method = report.salesByTender[method]) != null ? _report_salesByTender_method : 0) > 0 || ((_report_refundsByTender_method = report.refundsByTender[method]) != null ? _report_refundsByTender_method : 0) > 0;
+    });
+    return [
+        {
+            section: 'Sales',
+            rows: [
+                {
+                    label: 'Orders',
+                    value: String(report.orderCount)
+                },
+                {
+                    label: 'Gross sales',
+                    value: posMoney(report.grossSalesCents)
+                },
+                {
+                    label: 'Discounts',
+                    value: posMoney(report.discountsCents)
+                },
+                {
+                    label: 'Tax',
+                    value: posMoney(report.taxCents)
+                },
+                {
+                    label: 'Tips',
+                    value: posMoney(report.tipsCents)
+                },
+                {
+                    label: `Refunds (${report.refundCount})`,
+                    value: `-${posMoney(report.refundsCents)}`
+                },
+                {
+                    label: 'Net sales',
+                    value: posMoney(report.netSalesCents),
+                    strong: true
+                }
+            ]
+        },
+        {
+            section: 'By tender',
+            rows: tenders.length ? tenders.map((method)=>{
+                var _report_salesByTender_method, _report_refundsByTender_method, _report_refundsByTender_method1;
+                return {
+                    label: POS_TENDER_LABELS[method],
+                    value: posMoney((_report_salesByTender_method = report.salesByTender[method]) != null ? _report_salesByTender_method : 0) + (((_report_refundsByTender_method = report.refundsByTender[method]) != null ? _report_refundsByTender_method : 0) > 0 ? ` (−${posMoney((_report_refundsByTender_method1 = report.refundsByTender[method]) != null ? _report_refundsByTender_method1 : 0)})` : '')
+                };
+            }) : [
+                {
+                    label: 'No sales yet',
+                    value: ''
+                }
+            ]
+        },
+        {
+            section: 'Cash drawer',
+            rows: [
+                {
+                    label: 'Starting cash',
+                    value: posMoney(report.openingFloatCents)
+                },
+                {
+                    label: 'Cash sales',
+                    value: posMoney(report.cashSalesCents)
+                },
+                {
+                    label: 'Paid in',
+                    value: posMoney(report.paidInCents)
+                },
+                {
+                    label: 'Paid out',
+                    value: `-${posMoney(report.paidOutCents)}`
+                },
+                {
+                    label: 'Safe drops',
+                    value: `-${posMoney(report.dropsCents)}`
+                },
+                {
+                    label: 'Cash refunds',
+                    value: `-${posMoney(report.cashRefundsCents)}`
+                },
+                {
+                    label: 'Expected in drawer',
+                    value: posMoney(report.expectedCashCents),
+                    strong: true
+                },
+                ...(shift == null ? void 0 : shift.countedCashCents) != null ? [
+                    {
+                        label: 'Counted',
+                        value: posMoney(shift.countedCashCents)
+                    },
+                    {
+                        label: ((_shift_varianceCents = shift.varianceCents) != null ? _shift_varianceCents : 0) < 0 ? 'Short' : ((_shift_varianceCents1 = shift.varianceCents) != null ? _shift_varianceCents1 : 0) > 0 ? 'Over' : 'Balanced',
+                        value: posMoney((_shift_varianceCents2 = shift.varianceCents) != null ? _shift_varianceCents2 : 0),
+                        strong: true
+                    }
+                ] : []
+            ]
+        }
+    ];
+}
+/** A shift's X or Z report as the receipt printer prints it. */ export function posShiftPrintReport(input) {
+    return _extends({
+        title: input.title,
+        storeName: input.storeName
+    }, input.subtitle || input.registerName ? {
+        subtitle: [
+            input.registerName,
+            input.subtitle
+        ].filter(Boolean).join(' - ')
+    } : {}, {
+        sections: posShiftReportRows(input.report, input.shift)
+    });
+}
+
+//# sourceMappingURL=commerce-pos-ops.js.map