@final-commerce/command-frame 0.9.0-preprod.1 → 0.9.0-preprod.3

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, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation } from '@final-commerce/common/pos-types';
+import type { Tax, Tip, Address, MetadataItem, OrderAssignedUser, OrderInCart, OrderCustomStatus, 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, 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>;
@@ -7,6 +7,9 @@ export type CFDiscount = Discount;
 export type CFCustomFee = CustomFee;
 export type CFAddress = Address;
 export type CFMetadataItem = MetadataItem;
+export type CFOrderAssignedUser = OrderAssignedUser;
+export type CFOrderInCart = OrderInCart;
+export type CFOrderCustomStatus = OrderCustomStatus;
 export type CFTax = Tax;
 export type CFCartFeeTaxEntry = CartFeeTaxEntry;
 export type CFInventory = Inventory;

package/dist/actions/assign-order-user/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Assign order user action
+ * Calls the assignOrderUser action on the parent window
+ */
+import type { AssignOrderUser } from './types';
+export declare const assignOrderUser: AssignOrderUser;

package/dist/actions/assign-order-user/action.js

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

package/dist/actions/assign-order-user/mock.d.ts

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

package/dist/actions/assign-order-user/mock.js

@@ -0,0 +1,30 @@
+import { MOCK_ORDERS, MOCK_PARKED_ORDERS, MOCK_USERS, mockPublishEvent } from '../../demo/database';
+export const mockAssignOrderUser = async (params) => {
+    console.log('[Mock] assignOrderUser called', params);
+    if (!params?.orderId) {
+        throw new Error('assignOrderUser: the demo has no live-cart order — pass an orderId');
+    }
+    if (params.userId !== null && typeof params.userId !== 'string') {
+        throw new Error('assignOrderUser: userId must be a user id or null');
+    }
+    const order = [...MOCK_ORDERS, ...MOCK_PARKED_ORDERS].find((o) => o._id === params.orderId);
+    if (!order) {
+        throw new Error(`Order with ID ${params.orderId} not found`);
+    }
+    if (params.userId === null) {
+        order.assignedUser = null;
+    }
+    else if (order.assignedUser?.userId !== params.userId) {
+        if (!MOCK_USERS.some((u) => u.id === params.userId)) {
+            throw new Error(`User with ID ${params.userId} not found`);
+        }
+        order.assignedUser = { userId: params.userId, assignedAt: new Date().toISOString() };
+    }
+    mockPublishEvent('orders', 'order-updated', { order });
+    return {
+        success: true,
+        orderId: order._id,
+        assignedUser: order.assignedUser ?? null,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/assign-order-user/types.d.ts

@@ -0,0 +1,15 @@
+import type { CFOrderAssignedUser } from '../../CommonTypes';
+export interface AssignOrderUserParams {
+    /** Order to assign. Omit to target the live cart's order — it must already exist (parked, paid or transitioned). */
+    orderId?: string;
+    /** User to assign (e.g. the driver), or null to unassign. Replaces any current assignee. */
+    userId: string | null;
+}
+export interface AssignOrderUserResponse {
+    success: boolean;
+    orderId: string;
+    /** The order's assignee after the call; null when unassigned. */
+    assignedUser: CFOrderAssignedUser | null;
+    timestamp: string;
+}
+export type AssignOrderUser = (params: AssignOrderUserParams) => Promise<AssignOrderUserResponse>;

package/dist/actions/assign-order-user/types.js

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

package/dist/actions/get-current-cart/mock.d.ts

@@ -1,2 +1,2 @@
-import { GetCurrentCart } from "./types";
+import { GetCurrentCart } from './types';
 export declare const mockGetCurrentCart: GetCurrentCart;

package/dist/actions/get-current-cart/mock.js

@@ -1,9 +1,12 @@
-import { MOCK_CART, safeSerialize } from "../../demo/database";
+import { MOCK_CART, safeSerialize } from '../../demo/database';
 export const mockGetCurrentCart = async () => {
-    console.log("[Mock] getCurrentCart called");
+    console.log('[Mock] getCurrentCart called');
     return {
         success: true,
         cart: safeSerialize(MOCK_CART),
-        timestamp: new Date().toISOString()
+        // Every mock tender settles the whole sale and clears the cart, so the demo cart
+        // never holds an order with money on it — nothing to lock.
+        itemsLocked: false,
+        timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/get-current-cart/types.d.ts

@@ -1,7 +1,13 @@
-import { CFActiveCart } from "../../CommonTypes";
+import { CFActiveCart } from '../../CommonTypes';
 export interface GetCurrentCartResponse {
     success: boolean;
     cart: CFActiveCart;
+    /**
+     * `true` while the order in this cart has any payment on it (a split leg, a part payment,
+     * or paid in full): its items, amounts and customer can no longer be changed — the
+     * value-changing cart commands and clearCart refuse. Absent on hosts that predate the lock.
+     */
+    itemsLocked?: boolean;
     timestamp: string;
 }
 export type GetCurrentCart = () => Promise<GetCurrentCartResponse>;

package/dist/actions/get-order-statuses/action.d.ts

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

package/dist/actions/get-order-statuses/action.js

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

package/dist/actions/get-order-statuses/mock.d.ts

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

package/dist/actions/get-order-statuses/mock.js

@@ -0,0 +1,5 @@
+import { MOCK_ORDER_STATUSES } from '../../demo/database';
+export const mockGetOrderStatuses = async () => {
+    console.log('[Mock] getOrderStatuses called');
+    return { success: true, statuses: MOCK_ORDER_STATUSES.map((s) => ({ ...s })), timestamp: new Date().toISOString() };
+};

package/dist/actions/get-order-statuses/types.d.ts

@@ -0,0 +1,8 @@
+import type { CFOrderStatusDefinition } from '../../common-types/order-state';
+export interface GetOrderStatusesResponse {
+    success: boolean;
+    /** The company's order statuses, in the order they were defined. Empty when none are defined. */
+    statuses: CFOrderStatusDefinition[];
+    timestamp: string;
+}
+export type GetOrderStatuses = () => Promise<GetOrderStatusesResponse>;

package/dist/actions/get-order-statuses/types.js

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

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

@@ -2,5 +2,5 @@
  * Get orders action
  * Calls the getOrders action on the parent window
  */
-import type { GetOrders } from "./types";
+import type { GetOrders } from './types';
 export declare const getOrders: GetOrders;

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

@@ -2,7 +2,7 @@
  * Get orders action
  * Calls the getOrders action on the parent window
  */
-import { commandFrameClient } from "../../client";
+import { commandFrameClient } from '../../client';
 export const getOrders = async (params) => {
-    return await commandFrameClient.call("getOrders", params);
+    return await commandFrameClient.call('getOrders', params);
 };

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

@@ -1,2 +1,2 @@
-import { GetOrders } from "./types";
+import { GetOrders } from './types';
 export declare const mockGetOrders: GetOrders;

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

@@ -1,26 +1,73 @@
-import { MOCK_ORDERS, MOCK_PARKED_ORDERS, MOCK_USERS, MOCK_STATIONS, MOCK_OUTLETS, safeSerialize } from "../../demo/database";
+import { MOCK_ORDERS, MOCK_PARKED_ORDERS, MOCK_USERS, MOCK_STATIONS, MOCK_OUTLETS, safeSerialize, } from '../../demo/database';
 export const mockGetOrders = async (params) => {
-    console.log("[Mock] getOrders called", params);
+    console.log('[Mock] getOrders called', params);
     // Start with a safe copy of mock orders, including parked (status: "parked").
     let orders = safeSerialize([...MOCK_ORDERS, ...MOCK_PARKED_ORDERS]);
     // Filter simulation
     if (params) {
-        const { customerId, status, sessionId, searchValue, limit, offset, sortBy, sortDirection } = params;
+        const { customerId, status, sessionId, paymentState, fulfillmentState, outletId, assignedUserId, inCart, orderType, customStatusId, scheduled, scheduledFrom, scheduledTo, searchValue, limit, offset, sortBy, sortDirection, } = params;
         // 1. Filtering
         if (customerId) {
-            orders = orders.filter(o => o.customer &&
-                '_id' in o.customer &&
-                o.customer._id === customerId);
+            orders = orders.filter((o) => o.customer && '_id' in o.customer && o.customer._id === customerId);
         }
         if (status) {
-            orders = orders.filter(o => o.status === status);
+            orders = orders.filter((o) => o.status === status);
         }
         if (sessionId) {
-            orders = orders.filter(o => o.sessionId === sessionId);
+            orders = orders.filter((o) => o.sessionId === sessionId);
+        }
+        const anyOf = (criteria, value) => criteria === undefined ||
+            (Array.isArray(criteria) ? criteria.length === 0 || criteria.includes(value ?? '') : criteria === value);
+        if (paymentState !== undefined) {
+            orders = orders.filter((o) => anyOf(paymentState, o.paymentState));
+        }
+        if (fulfillmentState !== undefined) {
+            orders = orders.filter((o) => anyOf(fulfillmentState, o.fulfillmentState));
+        }
+        if (outletId) {
+            orders = orders.filter((o) => o.posData?.outlet === outletId);
+        }
+        if (assignedUserId) {
+            orders = orders.filter((o) => o.assignedUser?.userId === assignedUserId);
+        }
+        else if (assignedUserId === null) {
+            orders = orders.filter((o) => o.assignedUser == null);
+        }
+        if (orderType !== undefined) {
+            const types = Array.isArray(orderType) ? orderType : [orderType];
+            if (types.length)
+                orders = orders.filter((o) => types.includes(o.orderType ?? ''));
+        }
+        if (customStatusId !== undefined) {
+            const ids = Array.isArray(customStatusId) ? customStatusId : [customStatusId];
+            if (ids.length)
+                orders = orders.filter((o) => !!o.customStatus && ids.includes(o.customStatus.id));
+        }
+        // Requested time (setScheduledFor). ISO strings in UTC compare correctly as strings.
+        const scheduledOf = (o) => o.scheduledFor ?? null;
+        if (typeof scheduled === 'boolean') {
+            orders = orders.filter((o) => (scheduledOf(o) !== null) === scheduled);
+        }
+        if (scheduledFrom) {
+            const from = new Date(scheduledFrom).toISOString();
+            orders = orders.filter((o) => (scheduledOf(o) ?? '') !== '' && scheduledOf(o) >= from);
+        }
+        if (scheduledTo) {
+            const to = new Date(scheduledTo).toISOString();
+            orders = orders.filter((o) => (scheduledOf(o) ?? '') !== '' && scheduledOf(o) <= to);
+        }
+        if (typeof inCart === 'boolean') {
+            // Mirrors common's isInCart: the flag when present, else the legacy reading.
+            const orderInCart = (o) => o.inCart != null
+                ? o.inCart.active
+                : o.fulfillmentState
+                    ? o.fulfillmentState === 'draft'
+                    : o.status === 'in-cart';
+            orders = orders.filter((o) => orderInCart(o) === inCart);
         }
         if (searchValue) {
             const searchLower = String(searchValue).toLowerCase();
-            orders = orders.filter(o => {
+            orders = orders.filter((o) => {
                 const receiptMatch = o.receiptId?.toLowerCase().includes(searchLower);
                 const customerNameMatch = o.customer && 'firstName' in o.customer
                     ? `${o.customer.firstName} ${o.customer.lastName}`.toLowerCase().includes(searchLower)
@@ -36,20 +83,21 @@ export const mockGetOrders = async (params) => {
             orders.sort((a, b) => {
                 let valA = a[sortBy];
                 let valB = b[sortBy];
+                // Like the host: a missing time sorts as '' (first when ascending).
+                if (sortBy === 'scheduledFor') {
+                    valA = valA ?? '';
+                    valB = valB ?? '';
+                }
                 // Handle nested sort fields if necessary, basic support for now
                 if (!valA && sortBy === 'createdAt')
                     valA = a.createdAt || '';
                 if (!valB && sortBy === 'createdAt')
                     valB = b.createdAt || '';
                 if (typeof valA === 'string' && typeof valB === 'string') {
-                    return sortDirection === 'descending'
-                        ? valB.localeCompare(valA)
-                        : valA.localeCompare(valB);
+                    return sortDirection === 'descending' ? valB.localeCompare(valA) : valA.localeCompare(valB);
                 }
                 // Number comparison
-                return sortDirection === 'descending'
-                    ? (valB || 0) - (valA || 0)
-                    : (valA || 0) - (valB || 0);
+                return sortDirection === 'descending' ? (valB || 0) - (valA || 0) : (valA || 0) - (valB || 0);
             });
         }
         else {
@@ -73,21 +121,21 @@ export const mockGetOrders = async (params) => {
         if (enrichedOrder.posData) {
             // Enrich Employee
             if (typeof enrichedOrder.posData.employee === 'string') {
-                const employee = MOCK_USERS.find(u => u.id === enrichedOrder.posData.employee);
+                const employee = MOCK_USERS.find((u) => u.id === enrichedOrder.posData.employee);
                 if (employee) {
                     enrichedOrder.posData.employee = employee;
                 }
             }
             // Enrich Station
             if (typeof enrichedOrder.posData.station === 'string') {
-                const station = MOCK_STATIONS.find(s => s._id === enrichedOrder.posData.station);
+                const station = MOCK_STATIONS.find((s) => s._id === enrichedOrder.posData.station);
                 if (station) {
                     enrichedOrder.posData.station = station;
                 }
             }
             // Enrich Outlet
             if (typeof enrichedOrder.posData.outlet === 'string') {
-                const outlet = MOCK_OUTLETS.find(o => o.id === enrichedOrder.posData.outlet);
+                const outlet = MOCK_OUTLETS.find((o) => o.id === enrichedOrder.posData.outlet);
                 if (outlet) {
                     enrichedOrder.posData.outlet = outlet;
                 }
@@ -99,6 +147,6 @@ export const mockGetOrders = async (params) => {
         success: true,
         orders: enrichedOrders,
         total: MOCK_ORDERS.length, // Total before pagination
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

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

@@ -1,15 +1,41 @@
-import { CFOrder } from "../../CommonTypes";
+import { CFOrder } from '../../CommonTypes';
 export interface GetOrdersParams {
     /** e.g. 'completed', 'parked', 'refunded'. */
     status?: string;
     customerId?: string;
     sessionId?: string;
+    /** Payment state(s), e.g. 'paid' or ['unpaid', 'partially_paid']. A list matches any of them. */
+    paymentState?: string | string[];
+    /** Fulfillment state(s), e.g. 'in_progress' or ['pending', 'in_progress']. A list matches any of them. */
+    fulfillmentState?: string | string[];
+    /** Only orders placed at this outlet (`posData.outlet`). Without it, orders from every outlet in the company are returned. */
+    outletId?: string;
+    /**
+     * Only orders assigned to this user (`assignedUser.userId`), e.g. a driver's deliveries.
+     * `null`: only orders nobody is assigned to yet (e.g. deliveries awaiting a driver).
+     */
+    assignedUserId?: string | null;
+    /**
+     * true: only orders loaded in a cart; false: only orders that aren't. Reads `order.inCart` when the order
+     * carries it, otherwise the legacy reading (fulfillment 'draft' / status 'in-cart').
+     */
+    inCart?: boolean;
+    /** Order type label(s) set with setOrderType, e.g. 'delivery' or ['pickup', 'takeout']. Exact match; a list matches any. */
+    orderType?: string | string[];
+    /** Custom status id(s) set with setOrderStatus, e.g. 'in-kitchen'. A list matches any of them. */
+    customStatusId?: string | string[];
+    /** true: only orders with a time (setScheduledFor); false: only "as soon as possible" orders (no time). */
+    scheduled?: boolean;
+    /** Only orders scheduled at or after this ISO 8601 date-time. Orders with no time never match. */
+    scheduledFrom?: string;
+    /** Only orders scheduled at or before this ISO 8601 date-time. Orders with no time never match. */
+    scheduledTo?: string;
     /** Default: 50. */
     limit?: number;
     /** Default: 0. */
     offset?: number;
     searchValue?: string;
-    /** Default: 'createdAt'. */
+    /** Default: 'createdAt'. 'scheduledFor' sorts by the customer's requested time — orders with no time come first ascending. */
     sortBy?: string;
     /** Default: 'descending'. */
     sortDirection?: 'ascending' | 'descending';

package/dist/actions/record-external-payment/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Record external payment action
+ * Calls the recordExternalPayment action on the parent window
+ */
+import type { RecordExternalPayment } from './types';
+export declare const recordExternalPayment: RecordExternalPayment;

package/dist/actions/record-external-payment/action.js

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

package/dist/actions/record-external-payment/mock.d.ts

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

package/dist/actions/record-external-payment/mock.js

@@ -0,0 +1,36 @@
+import { isFulfillmentState } from '@final-commerce/common';
+import { applyMockPayment, MOCK_CART } from '../../demo/database';
+export const mockRecordExternalPayment = async (params) => {
+    console.log('[Mock] recordExternalPayment called', params);
+    const label = typeof params?.label === 'string' ? params.label.trim() : '';
+    if (!label) {
+        throw new Error('recordExternalPayment: label is required');
+    }
+    const balanceDue = MOCK_CART.amountToBeCharged ?? MOCK_CART.total;
+    const amount = params.amount ?? balanceDue;
+    // Same rule as the host: positive, except on a zero-balance checkout.
+    if (!Number.isFinite(amount) || amount < 0 || (amount === 0 && balanceDue > 0)) {
+        throw new Error('recordExternalPayment: amount must be a positive integer (minor units)');
+    }
+    const target = params.checkoutFulfillmentTarget;
+    if (target !== undefined && !isFulfillmentState(target)) {
+        throw new Error(`recordExternalPayment: invalid checkoutFulfillmentTarget "${String(target)}"`);
+    }
+    if (amount > balanceDue) {
+        throw new Error(`recordExternalPayment: amount ${amount} exceeds the balance due ${balanceDue}`);
+    }
+    const order = applyMockPayment(amount, 'external', label);
+    const remainingBalance = MOCK_CART.remainingBalance ?? 0;
+    return {
+        success: true,
+        amount,
+        label,
+        paymentType: 'external',
+        change: 0,
+        cashRounding: 0,
+        order,
+        saleFinalized: !!order,
+        remainingBalance: order ? 0 : remainingBalance,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/record-external-payment/types.d.ts

@@ -0,0 +1,37 @@
+import { CFOrder } from '../../CommonTypes';
+export interface RecordExternalPaymentParams {
+    /**
+     * What the payment was — shown on the order and in reports, e.g. 'Paid online',
+     * 'Uber Eats', 'Voucher'. Required; trimmed. Not checked against a list, so keep
+     * labels consistent across flows.
+     */
+    label: string;
+    /**
+     * Amount to record, in integer MINOR currency units. Omit to record the full balance
+     * due (completing the order). Below the balance due it records a partial payment —
+     * the rest can be taken with any other tender. Above the balance due is an error.
+     */
+    amount?: number;
+    /** Fulfillment state to land on after full payment, e.g. 'pending' to keep the order going to the kitchen. */
+    checkoutFulfillmentTarget?: string;
+}
+export interface RecordExternalPaymentResponse {
+    success: boolean;
+    /** The amount recorded, in integer MINOR currency units. */
+    amount: number;
+    /** The label, as recorded. */
+    label: string;
+    paymentType: 'external';
+    /** Always 0 — no money changes hands at the terminal. */
+    change: number;
+    /** Always 0 — cash rounding applies to cash only. */
+    cashRounding: number;
+    /** The order once the sale completes; null for a partial (split) leg. */
+    order: CFOrder | null;
+    /** True when this payment settled the remaining balance. */
+    saleFinalized: boolean;
+    /** Balance still due after this payment, in integer MINOR currency units. */
+    remainingBalance: number;
+    timestamp: string;
+}
+export type RecordExternalPayment = (params: RecordExternalPaymentParams) => Promise<RecordExternalPaymentResponse>;

package/dist/actions/record-external-payment/types.js

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

package/dist/actions/release-from-cart/action.d.ts

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

package/dist/actions/release-from-cart/action.js

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

package/dist/actions/release-from-cart/mock.d.ts

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

package/dist/actions/release-from-cart/mock.js

@@ -0,0 +1,26 @@
+import { MOCK_CART, MOCK_ORDERS, resetMockCart, mockPublishEvent } from '../../demo/database';
+export const mockReleaseFromCart = async () => {
+    console.log('[Mock] releaseFromCart called');
+    if (!MOCK_CART.products.length) {
+        throw new Error('releaseFromCart: the cart is empty');
+    }
+    const now = new Date().toISOString();
+    // Best-effort: the demo has no live-cart order, so the cart becomes a new unpaid draft.
+    const order = {
+        _id: `order_released_${Date.now()}`,
+        receiptId: `REL-${MOCK_ORDERS.length + 1}`,
+        status: 'in-cart',
+        paymentState: 'unpaid',
+        fulfillmentState: 'draft',
+        inCart: { active: false, stationId: null, since: now },
+        lineItems: [],
+        customSales: [],
+        paymentMethods: [],
+        summary: { total: MOCK_CART.total },
+        createdAt: now,
+    };
+    MOCK_ORDERS.push(order);
+    resetMockCart();
+    mockPublishEvent('orders', 'order-updated', { order });
+    return { success: true, order, timestamp: now };
+};

package/dist/actions/release-from-cart/types.d.ts

@@ -0,0 +1,8 @@
+import type { CFOrder } from '../../CommonTypes';
+export interface ReleaseFromCartResponse {
+    success: boolean;
+    /** The order that left the cart, as saved — its state is unchanged and `inCart.active` is false. */
+    order: CFOrder;
+    timestamp: string;
+}
+export type ReleaseFromCart = () => Promise<ReleaseFromCartResponse>;

package/dist/actions/release-from-cart/types.js

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

package/dist/actions/resume-order/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resume order action
+ * Calls the resumeOrder action on the parent window
+ */
+import type { ResumeOrder } from './types';
+export declare const resumeOrder: ResumeOrder;

package/dist/actions/resume-order/action.js

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

package/dist/actions/resume-order/mock.d.ts

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

package/dist/actions/resume-order/mock.js

@@ -0,0 +1,55 @@
+import { MOCK_ORDERS, MOCK_PARKED_ORDERS, mockPublishEvent } from '../../demo/database';
+import { restoreMockCartFromOrder } from '../resume-parked-order/mock';
+// Mirrors the host's rule (see README): anything not already in a cart and not finished.
+const BLOCKED_PAYMENT = new Set(['refunded', 'partially_refunded', 'voided', 'payment_pending']);
+const FINISHED_FULFILLMENT = new Set(['cancelled', 'returned', 'partially_returned']);
+export const mockResumeOrder = async (params) => {
+    console.log('[Mock] resumeOrder called', params);
+    const orderId = params?.orderId;
+    if (!orderId) {
+        throw new Error('Order ID is required');
+    }
+    const order = [...MOCK_PARKED_ORDERS, ...MOCK_ORDERS].find((o) => o._id === orderId);
+    if (!order) {
+        throw new Error(`Order with ID ${orderId} not found`);
+    }
+    const from = { payment: order.paymentState ?? 'unpaid', fulfillment: order.fulfillmentState ?? 'draft' };
+    const inCart = order.inCart != null ? order.inCart.active : from.fulfillment === 'draft';
+    if (inCart) {
+        throw new Error(`Order ${orderId} is already in a cart`);
+    }
+    if (BLOCKED_PAYMENT.has(from.payment) ||
+        FINISHED_FULFILLMENT.has(from.fulfillment) ||
+        (from.payment === 'paid' && from.fulfillment === 'fulfilled')) {
+        throw new Error(`Order ${orderId} cannot be resumed from ${from.payment} × ${from.fulfillment}`);
+    }
+    // Keeps the state; only parked (on_hold) / draft move.
+    const leavesParked = from.fulfillment === 'on_hold' || from.fulfillment === 'draft';
+    const to = {
+        payment: from.payment,
+        fulfillment: !leavesParked ? from.fulfillment : from.payment === 'unpaid' ? 'draft' : 'in_progress',
+    };
+    restoreMockCartFromOrder(order);
+    const parkedIndex = MOCK_PARKED_ORDERS.findIndex((o) => o._id === orderId);
+    if (parkedIndex !== -1)
+        MOCK_PARKED_ORDERS.splice(parkedIndex, 1);
+    mockPublishEvent('cart', 'cart-created', { orderId });
+    mockPublishEvent('order-state', 'state-transition-completed', {
+        orderId,
+        from,
+        to,
+        timestamp: new Date().toISOString(),
+    });
+    return {
+        success: true,
+        order: {
+            ...order,
+            paymentState: to.payment,
+            fulfillmentState: to.fulfillment,
+            inCart: { active: true, stationId: null, since: new Date().toISOString() },
+        },
+        from,
+        to,
+        timestamp: new Date().toISOString(),
+    };
+};