@final-commerce/command-frame 0.6.2-staging3.1 → 0.7.0-staging.10

package/dist/CommonTypes.d.ts

@@ -1,5 +1,5 @@
 export * from './common-types';
-import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment } from '@final-commerce/common/pos-types';
+import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation } from '@final-commerce/common/pos-types';
 export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from '@final-commerce/common';
 /** Open record used as a base for active entities. */
 export type CFActiveEntity = Record<string, unknown>;
@@ -18,19 +18,16 @@ export type CFTransaction = Transaction;
 export type CFCategory = Category;
 export type CFProductVariant = ProductVariant;
 export type CFProduct = FullProduct;
-/** Modifier (the till question) resolved onto a product — `CFProduct.modifiers`. */
-export type CFResolvedModifier = ResolvedModifier;
-export type CFResolvedModifierChoice = ResolvedModifierChoice;
-export type CFModifierSelectionType = ModifierSelectionType;
-/** One selected modifier choice on an order line item (wire shape). */
-export type CFOrderLineItemModifier = OrderLineItemModifier;
-/** Cart-line modifier answer (pre-pricing) — `CFActiveProduct.modifierSelections`. */
-export type CFModifierSelection = ModifierSelection;
-export type CFModifierChoiceSelection = ModifierChoiceSelection;
-/** One selected choice PRICED onto a cart line — `CFActiveProduct.modifiers` (not the resolved stack). */
-export type CFCartLineModifier = CartLineModifier;
-/** A priced, line-extended modifier row: "Toppings - Avocado" x2, `amount` 1000. */
-export type CFProdModifierBreakdown = ProdModifierBreakdown;
+export type CFBookingAvailability = BookingAvailability;
+export type CFBookingSlot = BookingSlot;
+export type CFBookingSlotResource = BookingSlotResource;
+export type CFBookingResource = BookingResource;
+export type CFBooking = Booking;
+/** A service sitting in the cart, and the same sale once it is on an order. A flow that draws a
+ *  cart or a receipt needs both by name — reaching into the package's dist for them is not an
+ *  interface. */
+export type CFCartReservation = CartReservation;
+export type CFOrderReservation = OrderReservation;
 export type CFActiveProduct = ActiveProduct;
 export type CFCustomer = ActiveCustomer;
 export type CFActiveCustomer = ActiveCustomer;
@@ -119,6 +116,21 @@ export interface CFContextRender {
     stationName: string | null;
     outletId: string | null;
     outletName: string | null;
+    /**
+     * IANA zone the SHOP keeps, resolved as the outlet's own zone, else the
+     * company's — never the device's. A booking is stored as an instant, so which
+     * hour and which DAY it reads as is decided entirely by the zone it is printed
+     * in, and the screen's own machine is the one zone that is certainly wrong: a
+     * 17:00 Monday appointment in Vancouver is 21:30 for a till in St John's, and
+     * for some viewers it lands on Tuesday. Without this an app cannot label a
+     * slot or an appointment honestly — it can only guess, and it guesses wrong
+     * for every business that does not sit in the same zone as its screen.
+     *
+     * `null` when neither the outlet nor the company has one configured. Say so
+     * rather than falling back to the device: a missing timezone is a setup
+     * problem, and printing the machine's clock hides it.
+     */
+    timeZone: string | null;
     buildId: string | null;
     buildName: string | null;
     buildVersion: string | null;

package/dist/actions/add-booking-to-cart/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Add booking to cart action
+ * Calls the addBookingToCart action on the parent window
+ */
+import type { AddBookingToCart } from './types';
+export declare const addBookingToCart: AddBookingToCart;

package/dist/actions/add-booking-to-cart/action.js

@@ -0,0 +1,8 @@
+/**
+ * Add booking to cart action
+ * Calls the addBookingToCart action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const addBookingToCart = async (params) => {
+    return await commandFrameClient.call('addBookingToCart', params);
+};

package/dist/actions/add-booking-to-cart/mock.d.ts

@@ -0,0 +1,2 @@
+import { AddBookingToCart } from './types';
+export declare const mockAddBookingToCart: AddBookingToCart;

package/dist/actions/add-booking-to-cart/mock.js

@@ -0,0 +1,42 @@
+import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from '../../demo/database';
+import { mockHoldBooking } from '../hold-booking/mock';
+export const mockAddBookingToCart = async (params) => {
+    console.log('[Mock] addBookingToCart called', params);
+    // One call, two effects — the window is claimed AND the service is in the cart. The claim goes
+    // first and its refusal propagates: a cart line for a window somebody else took is worse than
+    // no line at all.
+    const { booking } = await mockHoldBooking(params);
+    const product = MOCK_PRODUCTS.find(({ _id }) => _id === params.productId);
+    const variant = params.variantId
+        ? product?.variants?.find(({ _id }) => _id === params.variantId)
+        : product?.variants?.[0];
+    const price = variant?.price ?? product?.minPrice ?? 0;
+    const reservation = {
+        internalId: `res_${booking.id}`,
+        bookingId: booking.id,
+        productId: params.productId,
+        variantId: variant?._id ?? null,
+        resourceId: params.resourceId,
+        name: product?.name ?? 'Booking',
+        resourceName: booking.resourceName,
+        price,
+        quantity: 1,
+        total: price,
+        taxTableId: product?.taxTable,
+        startAt: booking.startAt,
+        endAt: booking.endAt,
+        bufferEndAt: booking.bufferEndAt,
+        expiresAt: booking.expiresAt,
+    };
+    if (!MOCK_CART.reservations)
+        MOCK_CART.reservations = [];
+    MOCK_CART.reservations.push(reservation);
+    MOCK_CART.subtotal += price;
+    MOCK_CART.total += price;
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
+    // The cart topic, not the bookings one: a screen that only watches bookings still has to
+    // repaint its cart, and every other cart mutation announces itself the same way.
+    mockPublishEvent('cart', 'reservation-added', { reservation });
+    return { booking, reservationInternalId: reservation.internalId, timestamp: new Date().toISOString() };
+};

package/dist/actions/add-booking-to-cart/types.d.ts

@@ -0,0 +1,23 @@
+import { CFBooking } from '../../CommonTypes';
+export interface AddBookingToCartParams {
+    /** The bookable product (`productType: 'booking'`). */
+    productId: string;
+    /** Which resource serves it: a member of staff, a room, a scooter. */
+    resourceId: string;
+    /** Must be the START of a slot getBookingAvailability offered, ISO 8601. */
+    startAt: string;
+    /** End of the window — the slot's own `endAt`, or the last slot's for a stay. */
+    endAt: string;
+    /** The variant being sold. Defaults to the product's only variant. */
+    variantId?: string;
+    /** Whom the booking is for. Omit for a walk-in. */
+    customerId?: string;
+}
+export interface AddBookingToCartResponse {
+    /** The claim the cart now stands on: `id` cancels or releases it, `expiresAt` is your clock. */
+    booking: CFBooking;
+    /** Identity of the reservation inside the cart and, later, the order. */
+    reservationInternalId: string;
+    timestamp: string;
+}
+export type AddBookingToCart = (params: AddBookingToCartParams) => Promise<AddBookingToCartResponse>;

package/dist/actions/add-product-to-cart/mock.js

@@ -1,4 +1,4 @@
-import { MOCK_CART, MOCK_PRODUCTS, buildCartLineModifiers, buildModifierRows, mockPublishEvent, } from '../../demo/database';
+import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from '../../demo/database';
 import { extendPrice, isValidQuantity, resolveUnit } from '@final-commerce/common';
 export const mockAddProductToCart = async (params) => {
     console.log('[Mock] addProductToCart called', params);
@@ -53,18 +53,6 @@ export const mockAddProductToCart = async (params) => {
         note: note,
         // discount/fee could be added here to mock object if CFActiveProduct supports it
     };
-    // The spread above copied the PRODUCT's `modifiers` — a ResolvedModifier[] menu — into a
-    // field that means "the choices this line carries" (CartLineModifier[]). Two different
-    // shapes, one name. Drop it before anything reads the line, or every surface renders the
-    // whole catalogue as if the cashier had picked all of it.
-    delete activeProduct.modifiers;
-    // Keep the raw answers AND the priced rows, the same pair the real host writes. The cart
-    // TOTAL is deliberately left alone: like a product fee (see add-product-fee), per-line
-    // money is not accumulated by this mock — `total` stays Σ extendPrice(price, quantity).
-    if (params?.modifiers?.length) {
-        activeProduct.modifierSelections = params.modifiers;
-        activeProduct.modifiers = buildCartLineModifiers(product.modifiers, params.modifiers, product.taxTable);
-    }
     MOCK_CART.products.push(activeProduct);
     // Recalculate totals. extendPrice, not a raw multiply: a fractional quantity times an
     // integer-minor price leaves fractional cents, which no order may carry.
@@ -76,9 +64,6 @@ export const mockAddProductToCart = async (params) => {
     MOCK_CART.remainingBalance = MOCK_CART.total;
     // Publish cart event to simulate real behavior
     mockPublishEvent('cart', 'product-added', { product: activeProduct });
-    // Display-ready modifier rows for the line that was just created, so a flow can
-    // show what the modifiers added without re-reading the cart or multiplying.
-    const { rows, modifiersTotal } = buildModifierRows(activeProduct.modifiers, quantity);
     return {
         success: true,
         productId: activeProduct.id,
@@ -86,8 +71,6 @@ export const mockAddProductToCart = async (params) => {
         internalId: activeProduct.internalId,
         name: activeProduct.name,
         quantity: quantity,
-        rows,
-        modifiersTotal,
         timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/add-product-to-cart/types.d.ts

@@ -1,7 +1,5 @@
 import type { AddProductDiscountParams } from '../add-product-discount/types';
 import type { AddProductFeeParams } from '../add-product-fee/types';
-import type { ModifierSelection } from '../get-product-modifier-selections/types';
-import type { CFProdModifierBreakdown } from '../../CommonTypes';
 export interface AddProductToCartParams {
     /** ID of the variant to add. */
     variantId: string;
@@ -23,25 +21,17 @@ export interface AddProductToCartParams {
     discounts?: AddProductDiscountParams[];
     /** Array of fees to apply immediately. */
     fees?: AddProductFeeParams[];
-    /** Modifier selections to apply immediately. */
-    modifiers?: ModifierSelection[];
     /** Note or array of notes to add immediately. */
     notes?: string | string[];
 }
 export interface AddProductToCartResponse {
     success: boolean;
-    /** Set when the add was rejected (e.g. a required modifier is unanswered). */
-    reason?: string;
     productId: string;
     variantId: string;
     /** The unique identifier for the specific item instance added to the cart. */
     internalId: string;
     name: string;
     quantity: number;
-    /** The modifiers the line was created with, display-ready. Empty when there are none. */
-    rows: CFProdModifierBreakdown[];
-    /** Sum of `rows[].amount` — what the modifiers added to this line, in minor units. */
-    modifiersTotal: number;
     timestamp: string;
 }
 export type AddProductToCart = (params?: AddProductToCartParams) => Promise<AddProductToCartResponse>;

package/dist/actions/cancel-booking/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cancel booking action
+ * Calls the cancelBooking action on the parent window
+ */
+import type { CancelBooking } from './types';
+export declare const cancelBooking: CancelBooking;

package/dist/actions/cancel-booking/action.js

@@ -0,0 +1,8 @@
+/**
+ * Cancel booking action
+ * Calls the cancelBooking action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const cancelBooking = async (params) => {
+    return await commandFrameClient.call('cancelBooking', params);
+};

package/dist/actions/cancel-booking/mock.d.ts

@@ -0,0 +1,2 @@
+import { CancelBooking } from './types';
+export declare const mockCancelBooking: CancelBooking;

package/dist/actions/cancel-booking/mock.js

@@ -0,0 +1,10 @@
+import { MOCK_BOOKINGS } from '../../demo/database';
+import { ReservationStatus } from '@final-commerce/common';
+export const mockCancelBooking = async (params) => {
+    console.log('[Mock] cancelBooking called', params);
+    const booking = MOCK_BOOKINGS.find(({ id }) => id === params.bookingId);
+    if (!booking)
+        throw new Error(`No booking ${params.bookingId}`);
+    booking.status = ReservationStatus.CANCELLED;
+    return { booking, timestamp: new Date().toISOString() };
+};

package/dist/actions/cancel-booking/types.d.ts

@@ -0,0 +1,10 @@
+import { CFBooking } from '../../CommonTypes';
+export interface CancelBookingParams {
+    /** `id` of the booking returned by holdBooking or getBookings. */
+    bookingId: string;
+}
+export interface CancelBookingResponse {
+    booking: CFBooking;
+    timestamp: string;
+}
+export type CancelBooking = (params: CancelBookingParams) => Promise<CancelBookingResponse>;

package/dist/actions/get-booking-availability/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get booking availability action
+ * Calls the getBookingAvailability action on the parent window
+ */
+import type { GetBookingAvailability } from './types';
+export declare const getBookingAvailability: GetBookingAvailability;

package/dist/actions/get-booking-availability/action.js

@@ -0,0 +1,8 @@
+/**
+ * Get booking availability action
+ * Calls the getBookingAvailability action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const getBookingAvailability = async (params) => {
+    return await commandFrameClient.call('getBookingAvailability', params);
+};

package/dist/actions/get-booking-availability/mock.d.ts

@@ -0,0 +1,2 @@
+import { GetBookingAvailability } from './types';
+export declare const mockGetBookingAvailability: GetBookingAvailability;

package/dist/actions/get-booking-availability/mock.js

@@ -0,0 +1,6 @@
+import { mockBookingAvailability } from '../../demo/database';
+export const mockGetBookingAvailability = async (params) => {
+    console.log('[Mock] getBookingAvailability called', params);
+    const availability = mockBookingAvailability(params.productId, new Date(params.from), new Date(params.to), params.resourceId);
+    return { availability, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-booking-availability/types.d.ts

@@ -0,0 +1,18 @@
+import { CFBookingAvailability } from '../../CommonTypes';
+export interface GetBookingAvailabilityParams {
+    /** The bookable product (`productType: 'booking'`) whose calendar you are drawing. */
+    productId: string;
+    /** Range start, ISO 8601. */
+    from: string;
+    /** Range end, ISO 8601. */
+    to: string;
+    /** Narrow the answer to one resource — "only Marco", "only room 4". */
+    resourceId?: string;
+    /** Narrow to the resources standing at one outlet. */
+    outletId?: string;
+}
+export interface GetBookingAvailabilityResponse {
+    availability: CFBookingAvailability;
+    timestamp: string;
+}
+export type GetBookingAvailability = (params: GetBookingAvailabilityParams) => Promise<GetBookingAvailabilityResponse>;

package/dist/actions/get-booking-resources/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get booking resources action
+ * Calls the getBookingResources action on the parent window
+ */
+import type { GetBookingResources } from './types';
+export declare const getBookingResources: GetBookingResources;

package/dist/actions/get-booking-resources/action.js

@@ -0,0 +1,8 @@
+/**
+ * Get booking resources action
+ * Calls the getBookingResources action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const getBookingResources = async (params) => {
+    return await commandFrameClient.call('getBookingResources', params);
+};

package/dist/actions/get-booking-resources/mock.d.ts

@@ -0,0 +1,2 @@
+import { GetBookingResources } from './types';
+export declare const mockGetBookingResources: GetBookingResources;

package/dist/actions/get-booking-resources/mock.js

@@ -0,0 +1,7 @@
+import { MOCK_BOOKING_RESOURCES } from '../../demo/database';
+export const mockGetBookingResources = async (params) => {
+    console.log('[Mock] getBookingResources called', params);
+    // A resource knows nothing about outlets — where it works lives in its own records, which the
+    // host reads. The mock has no such records, so `outletId` narrows nothing here.
+    return { resources: MOCK_BOOKING_RESOURCES, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-booking-resources/types.d.ts

@@ -0,0 +1,12 @@
+import { CFBookingResource } from '../../CommonTypes';
+export interface GetBookingResourcesParams {
+    /** Only the resources that serve this bookable product. Omit for the whole company. */
+    productId?: string;
+    /** Only resources standing at this outlet (a resource with no outlet serves all of them). */
+    outletId?: string;
+}
+export interface GetBookingResourcesResponse {
+    resources: CFBookingResource[];
+    timestamp: string;
+}
+export type GetBookingResources = (params?: GetBookingResourcesParams) => Promise<GetBookingResourcesResponse>;

package/dist/actions/get-booking-resources/types.js

@@ -0,0 +1 @@
+export {};

package/dist/actions/get-bookings/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get bookings action
+ * Calls the getBookings action on the parent window
+ */
+import type { GetBookings } from './types';
+export declare const getBookings: GetBookings;

package/dist/actions/get-bookings/action.js

@@ -0,0 +1,8 @@
+/**
+ * Get bookings action
+ * Calls the getBookings action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const getBookings = async (params) => {
+    return await commandFrameClient.call('getBookings', params);
+};

package/dist/actions/get-bookings/mock.d.ts

@@ -0,0 +1,2 @@
+import { GetBookings } from './types';
+export declare const mockGetBookings: GetBookings;

package/dist/actions/get-bookings/mock.js

@@ -0,0 +1,20 @@
+import { MOCK_BOOKINGS, mockLiveBookings } from '../../demo/database';
+export const mockGetBookings = async (params) => {
+    console.log('[Mock] getBookings called', params);
+    let bookings = params?.includeExpired ? MOCK_BOOKINGS : mockLiveBookings();
+    if (params?.resourceId)
+        bookings = bookings.filter((entry) => entry.resourceId === params.resourceId);
+    if (params?.productId)
+        bookings = bookings.filter((entry) => entry.productId === params.productId);
+    if (params?.customerId)
+        bookings = bookings.filter((entry) => entry.customerId === params.customerId);
+    if (params?.from) {
+        const from = new Date(params.from);
+        bookings = bookings.filter((entry) => new Date(entry.bufferEndAt) > from);
+    }
+    if (params?.to) {
+        const to = new Date(params.to);
+        bookings = bookings.filter((entry) => new Date(entry.startAt) < to);
+    }
+    return { bookings, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-bookings/types.d.ts

@@ -0,0 +1,18 @@
+import { CFBooking } from '../../CommonTypes';
+export interface GetBookingsParams {
+    /** Everything taking this resource's time — the one query a day view needs. */
+    resourceId?: string;
+    productId?: string;
+    /** This customer's appointments. */
+    customerId?: string;
+    /** Bookings whose window overlaps this range, ISO 8601. */
+    from?: string;
+    to?: string;
+    /** Defaults to live bookings only (confirmed, plus holds that have not expired). */
+    includeExpired?: boolean;
+}
+export interface GetBookingsResponse {
+    bookings: CFBooking[];
+    timestamp: string;
+}
+export type GetBookings = (params?: GetBookingsParams) => Promise<GetBookingsResponse>;

package/dist/actions/get-bookings/types.js

@@ -0,0 +1 @@
+export {};

package/dist/actions/get-context/mock.js

@@ -11,6 +11,10 @@ export const mockGetContext = () => {
         stationName: MOCK_STATION.name,
         outletId: MOCK_OUTLET.id,
         outletName: MOCK_OUTLET.name || null,
+        // Deliberately NOT the developer's own zone: an app that quietly formats with
+        // the machine's clock looks correct in preview and is wrong on every till that
+        // sits in a different city. Here it cannot look correct by accident.
+        timeZone: "America/Vancouver",
         buildId: "mock_build_id",
         buildName: "Mock Build",
         buildVersion: "1.0.0-mock",

package/dist/actions/get-refund-plan/types.d.ts

@@ -18,11 +18,14 @@ export interface GetRefundPlanParams {
      * nothing staged, no `allocation` comes back.
      */
     items?: {
-        /** `internalId` / `variantId` for a product, `customSaleId`, cart-fee id, or tip `transactionId`. */
+        /**
+         * `internalId` / `variantId` for a product, `customSaleId`, cart-fee id, tip
+         * `transactionId`, or a booking's own `internalId` on `order.reservations[]`.
+         */
         itemKey: string;
         quantity: number;
         /** Optional hint; inferred from the order when omitted. */
-        type?: 'product' | 'customSale' | 'fee' | 'tip';
+        type?: 'product' | 'customSale' | 'fee' | 'tip' | 'reservation';
     }[];
 }
 export interface RefundPlanSource {

package/dist/actions/get-remaining-refundable-quantities/mock.js

@@ -6,6 +6,7 @@ export const mockGetRemainingRefundableQuantities = async (_params) => {
         customSales: {},
         cartFees: {},
         tips: {},
+        reservations: {},
         timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/get-remaining-refundable-quantities/types.d.ts

@@ -18,6 +18,14 @@ export interface GetRemainingRefundableQuantitiesResponse {
      * 0/1 semantics: `1` = still refundable, `0` = already refunded.
      */
     tips: Record<string, number>;
+    /**
+     * Remaining refundable bookings, keyed by `order.reservations[].internalId` —
+     * the same key `processPartialRefund` takes for `type: 'reservation'` items.
+     * A service is sold as a reservation rather than a line item, so without this
+     * map a refund screen can show everything on the order EXCEPT the appointment.
+     * 0/1 semantics: `1` = still refundable, `0` = already refunded.
+     */
+    reservations: Record<string, number>;
     timestamp: string;
 }
 export type GetRemainingRefundableQuantities = (params?: GetRemainingRefundableQuantitiesParams) => Promise<GetRemainingRefundableQuantitiesResponse>;

package/dist/actions/hold-booking/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hold booking action
+ * Calls the holdBooking action on the parent window
+ */
+import type { HoldBooking } from './types';
+export declare const holdBooking: HoldBooking;

package/dist/actions/hold-booking/action.js

@@ -0,0 +1,8 @@
+/**
+ * Hold booking action
+ * Calls the holdBooking action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const holdBooking = async (params) => {
+    return await commandFrameClient.call('holdBooking', params);
+};

package/dist/actions/hold-booking/mock.d.ts

@@ -0,0 +1,2 @@
+import { HoldBooking } from './types';
+export declare const mockHoldBooking: HoldBooking;

package/dist/actions/hold-booking/mock.js

@@ -0,0 +1,33 @@
+import { MOCK_BOOKINGS, MOCK_BOOKING_RESOURCES, mockLiveBookings } from '../../demo/database';
+import { ReservationStatus } from '@final-commerce/common';
+const BUFFER_MINUTES = 5;
+const HOLD_MINUTES = 10;
+export const mockHoldBooking = async (params) => {
+    console.log('[Mock] holdBooking called', params);
+    const startAt = new Date(params.startAt);
+    const endAt = new Date(params.endAt);
+    const bufferEndAt = new Date(endAt.getTime() + BUFFER_MINUTES * 60000);
+    // The mock refuses a taken window like the host does. A mock that always said yes would
+    // let a booking screen ship without ever handling the one error it will actually meet.
+    const clash = mockLiveBookings().some((entry) => entry.resourceId === params.resourceId &&
+        new Date(entry.startAt) < bufferEndAt &&
+        new Date(entry.bufferEndAt) > startAt);
+    if (clash)
+        throw new Error('That window has just been taken — pick another slot.');
+    const booking = {
+        id: `bk_mock_${Date.now()}`,
+        productId: params.productId,
+        resourceId: params.resourceId,
+        variantId: params.variantId,
+        startAt: startAt.toISOString(),
+        endAt: endAt.toISOString(),
+        bufferEndAt: bufferEndAt.toISOString(),
+        customerId: params.customerId,
+        status: ReservationStatus.HELD,
+        expiresAt: new Date(Date.now() + HOLD_MINUTES * 60000).toISOString(),
+        resourceName: MOCK_BOOKING_RESOURCES.find(({ id }) => id === params.resourceId)?.name,
+    };
+    // Held in the same list availability reads, so the slot really does disappear.
+    MOCK_BOOKINGS.push(booking);
+    return { booking, timestamp: new Date().toISOString() };
+};

package/dist/actions/hold-booking/types.d.ts

@@ -0,0 +1,24 @@
+import { CFBooking } from '../../CommonTypes';
+export interface HoldBookingParams {
+    productId: string;
+    /** Which resource serves it: a member of staff, a room, a scooter. */
+    resourceId: string;
+    /** Must be the START of a slot the host offered, ISO 8601. */
+    startAt: string;
+    /**
+     * End of the window — the `endAt` of the slot you picked, or of the last slot in a stay.
+     * Required: the server refuses a window it cannot line up with its own grid, and the till
+     * has no local copy of the rules to derive it from.
+     */
+    endAt: string;
+    /** The variant being sold, when the flow already knows which one. */
+    variantId?: string;
+    /** Whom the booking is for. Omit for a walk-in. */
+    customerId?: string;
+}
+export interface HoldBookingResponse {
+    /** The claim. `expiresAt` says how long it survives unpaid; `id` is what you confirm or cancel. */
+    booking: CFBooking;
+    timestamp: string;
+}
+export type HoldBooking = (params: HoldBookingParams) => Promise<HoldBookingResponse>;

package/dist/actions/hold-booking/types.js

@@ -0,0 +1 @@
+export {};

package/dist/actions/process-partial-refund/types.d.ts

@@ -131,10 +131,10 @@ export interface ProcessPartialRefundParams {
     };
     /** Optional items to refund. */
     items?: {
-        /** internalId or variantId or customSaleId. */
+        /** internalId or variantId, customSaleId, or a booking's own internalId. */
         itemKey: string;
         quantity: number;
-        type?: 'product' | 'customSale' | 'fee' | 'tip';
+        type?: 'product' | 'customSale' | 'fee' | 'tip' | 'reservation';
         /**
          * Per-item stock disposition for a refunded **product** line — the
          * headless equivalent of the old refund popup's per-row restock/damaged

package/dist/actions/remove-booking-from-cart/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remove booking from cart action
+ * Calls the removeBookingFromCart action on the parent window
+ */
+import type { RemoveBookingFromCart } from './types';
+export declare const removeBookingFromCart: RemoveBookingFromCart;

package/dist/actions/remove-booking-from-cart/action.js

@@ -0,0 +1,8 @@
+/**
+ * Remove booking from cart action
+ * Calls the removeBookingFromCart action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const removeBookingFromCart = async (params) => {
+    return await commandFrameClient.call('removeBookingFromCart', params);
+};

package/dist/actions/remove-booking-from-cart/mock.d.ts

@@ -0,0 +1,2 @@
+import { RemoveBookingFromCart } from './types';
+export declare const mockRemoveBookingFromCart: RemoveBookingFromCart;