@final-commerce/command-frame 0.1.11 → 0.1.12

package/dist/actions/add-custom-sale/mock.js

@@ -1,14 +1,34 @@
+import { MOCK_CART } from "../../demo/database";
 export const mockAddCustomSale = async (params) => {
     console.log("[Mock] addCustomSale called", params);
     if (!params)
         throw new Error("Params required");
     // Simple mock ID generation
     const mockId = 'sale_' + Math.random().toString(36).substr(2, 9);
+    const price = Number(params.price);
+    const quantity = 1; // Default to 1 for custom sale usually
+    const customSale = {
+        id: mockId,
+        name: params.label,
+        price: price,
+        quantity: quantity,
+        applyTaxes: params.applyTaxes ?? false,
+        taxTableId: params.taxTableId
+    };
+    if (!MOCK_CART.customSales) {
+        MOCK_CART.customSales = [];
+    }
+    MOCK_CART.customSales.push(customSale);
+    // Update Cart Totals
+    MOCK_CART.subtotal += price * quantity;
+    MOCK_CART.total += price * quantity;
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
     return {
         success: true,
         customSaleId: mockId,
         label: params.label,
-        price: Number(params.price),
+        price: price,
         applyTaxes: params.applyTaxes ?? false,
         timestamp: new Date().toISOString()
     };

package/dist/actions/add-custom-sale/types.d.ts

@@ -2,6 +2,7 @@ export interface AddCustomSaleParams {
     label: string;
     price: number | string;
     applyTaxes?: boolean;
+    taxTableId?: string;
 }
 export interface AddCustomSaleResponse {
     success: boolean;

package/dist/actions/add-customer/mock.js

@@ -10,6 +10,7 @@ export const mockAddCustomer = async (params) => {
         updatedAt: new Date().toISOString()
     };
     MOCK_CUSTOMERS.push(newCustomer);
+    window.alert(`Demo: Customer Created!\nName: ${newCustomer.firstName} ${newCustomer.lastName}\nEmail: ${newCustomer.email}`);
     return {
         success: true,
         customer: newCustomer,

package/dist/actions/add-customer-note/mock.js

@@ -1,5 +1,18 @@
+import { MOCK_CUSTOMERS } from "../../demo/database";
 export const mockAddCustomerNote = async (params) => {
     console.log("[Mock] addCustomerNote called", params);
+    if (params?.customerId && params.note) {
+        const customer = MOCK_CUSTOMERS.find(c => c._id === params.customerId);
+        if (customer) {
+            if (!customer.notes) {
+                customer.notes = [];
+            }
+            customer.notes.push({
+                message: params.note,
+                createdAt: new Date().toISOString()
+            });
+        }
+    }
     return {
         success: true,
         customerId: params?.customerId || "",

package/dist/actions/add-order-note/mock.js

@@ -1,5 +1,15 @@
+import { MOCK_CART } from "../../demo/database";
 export const mockAddOrderNote = async (params) => {
     console.log("[Mock] addOrderNote called", params);
+    // In Render, AddOrderNote usually adds a note to the active cart if it's not checked out yet.
+    if (params?.note) {
+        if (MOCK_CART.orderNotes) {
+            MOCK_CART.orderNotes += "\n" + params.note;
+        }
+        else {
+            MOCK_CART.orderNotes = params.note;
+        }
+    }
     return {
         success: true,
         note: params?.note || "",

package/dist/actions/add-product-discount/mock.js

@@ -1,5 +1,24 @@
+import { MOCK_CART } from "../../demo/database";
 export const mockAddProductDiscount = async (params) => {
     console.log("[Mock] addProductDiscount called", params);
+    if (params && (params.amount > 0 || params.amount < 0)) { // Allow 0 to clear discount if logic permits
+        let item = null;
+        if (params.cartItemId) {
+            item = MOCK_CART.products.find(p => p.internalId === params.cartItemId);
+        }
+        else if (MOCK_CART.products.length > 0) {
+            item = MOCK_CART.products[MOCK_CART.products.length - 1];
+        }
+        if (item) {
+            item.discount = {
+                value: params.amount,
+                isPercent: params.isPercent || false,
+                label: params.label
+            };
+            // Recalculate cart totals (simplified)
+            // Ideally, this should trigger a full recalculation function
+        }
+    }
     return {
         success: true,
         amount: params?.amount || 0,

package/dist/actions/add-product-fee/mock.js

@@ -1,5 +1,23 @@
+import { MOCK_CART } from "../../demo/database";
 export const mockAddProductFee = async (params) => {
     console.log("[Mock] addProductFee called", params);
+    if (params) {
+        let item = null;
+        if (params.cartItemId) {
+            item = MOCK_CART.products.find(p => p.internalId === params.cartItemId);
+        }
+        else if (MOCK_CART.products.length > 0) {
+            item = MOCK_CART.products[MOCK_CART.products.length - 1];
+        }
+        if (item) {
+            item.fee = {
+                label: params.label || "Fee",
+                amount: params.amount,
+                isPercent: params.isPercent || false,
+                applyTaxes: params.applyTaxes || false
+            };
+        }
+    }
     return {
         success: true,
         amount: params?.amount || 0,

package/dist/actions/add-product-note/mock.js

@@ -1,5 +1,16 @@
+import { MOCK_CART } from "../../demo/database";
 export const mockAddProductNote = async (params) => {
     console.log("[Mock] addProductNote called", params);
+    if (params?.note && params.cartItemId) {
+        const item = MOCK_CART.products.find(p => p.internalId === params.cartItemId);
+        if (item) {
+            item.note = params.note;
+        }
+    }
+    else if (params?.note && MOCK_CART.products.length > 0) {
+        // Fallback to last added item if no ID provided (common behavior in some POS flows)
+        MOCK_CART.products[MOCK_CART.products.length - 1].note = params.note;
+    }
     return {
         success: true,
         note: params?.note || "",

package/dist/actions/adjust-inventory/mock.js

@@ -1,13 +1,31 @@
+import { MOCK_PRODUCTS } from "../../demo/database";
 export const mockAdjustInventory = async (params) => {
     console.log("[Mock] adjustInventory called", params);
-    // Simulate updating inventory
-    let newStock = 100;
-    if (params?.stockType === 'add')
-        newStock += Number(params.amount);
-    if (params?.stockType === 'subtract')
-        newStock -= Number(params.amount);
-    if (params?.stockType === 'set')
-        newStock = Number(params.amount);
+    let newStock = 0;
+    if (params && params.productId) {
+        const product = MOCK_PRODUCTS.find(p => p._id === params.productId);
+        if (product) {
+            // Find variant
+            const variant = params.variantId
+                ? product.variants.find(v => v._id === params.variantId)
+                : product.variants[0];
+            if (variant && variant.inventory && variant.inventory.length > 0) {
+                const currentStock = variant.inventory[0].stock || 0;
+                const changeAmount = Number(params.amount);
+                if (params.stockType === 'add') {
+                    newStock = currentStock + changeAmount;
+                }
+                else if (params.stockType === 'subtract') {
+                    newStock = currentStock - changeAmount;
+                }
+                else {
+                    newStock = changeAmount;
+                }
+                // Update mock DB
+                variant.inventory[0].stock = newStock;
+            }
+        }
+    }
     return {
         success: true,
         amount: params?.amount || "0",

package/dist/actions/adjust-inventory/types.d.ts

@@ -4,6 +4,7 @@ export interface AdjustInventoryParams {
     /** 'add' (increase), 'subtract' (decrease), or 'set' (recount). */
     stockType: 'add' | 'subtract' | 'set';
     variantId?: string;
+    productId?: string;
 }
 export interface AdjustInventoryResponse {
     success: boolean;

package/dist/actions/assign-customer/mock.js

@@ -6,6 +6,7 @@ export const mockAssignCustomer = async (params) => {
         throw new Error("Customer not found in mock DB");
     }
     MOCK_CART.customer = customer;
+    window.alert(`Demo: Customer Assigned to Cart\nName: ${customer.firstName} ${customer.lastName}`);
     return {
         success: true,
         customer,

package/dist/actions/cash-payment/action.js

@@ -4,5 +4,9 @@
  */
 import { commandFrameClient } from "../../client";
 export const cashPayment = async (params) => {
-    return await commandFrameClient.call("cashPayment", params);
+    const finalParams = {
+        ...params,
+        openChangeCalculator: params?.openChangeCalculator ?? true
+    };
+    return await commandFrameClient.call("cashPayment", finalParams);
 };

package/dist/actions/cash-payment/mock.js

@@ -1,12 +1,44 @@
-import { createOrderFromCart } from "../../demo/database";
+import { createOrderFromCart, MOCK_CART } from "../../demo/database";
 export const mockCashPayment = async (params) => {
     console.log("[Mock] cashPayment called", params);
-    const amount = params?.amount || 0;
+    // Default to true to match action behavior
+    const openChangeCalculator = params?.openChangeCalculator ?? true;
+    let amount = params?.amount || MOCK_CART.total;
+    if (openChangeCalculator) {
+        try {
+            const input = window.prompt(`Total Due: $${MOCK_CART.total.toFixed(2)}\nEnter amount tendered:`, amount.toString());
+            if (input === null) {
+                // User cancelled
+                return {
+                    success: false,
+                    amount: 0,
+                    openChangeCalculator,
+                    paymentType: "cash",
+                    order: null,
+                    timestamp: new Date().toISOString()
+                };
+            }
+            const tendered = parseFloat(input);
+            if (!isNaN(tendered)) {
+                amount = tendered;
+                const change = tendered - MOCK_CART.total;
+                if (change >= 0) {
+                    window.alert(`Change Due: $${change.toFixed(2)}`);
+                }
+                else {
+                    window.alert(`Warning: Tendered amount is less than total. Short by: $${Math.abs(change).toFixed(2)}`);
+                }
+            }
+        }
+        catch (e) {
+            console.warn("Could not open prompt/alert (possibly in non-interactive environment)", e);
+        }
+    }
     const order = createOrderFromCart("cash", amount, "cash");
     return {
         success: true,
         amount,
-        openChangeCalculator: params?.openChangeCalculator || false,
+        openChangeCalculator,
         paymentType: "cash",
         order,
         timestamp: new Date().toISOString()

package/dist/actions/delete-parked-order/mock.js

@@ -1,5 +1,12 @@
+import { MOCK_PARKED_ORDERS } from "../../demo/database";
 export const mockDeleteParkedOrder = async (params) => {
     console.log("[Mock] deleteParkedOrder called", params);
+    if (params?.orderId) {
+        const index = MOCK_PARKED_ORDERS.findIndex(o => o._id === params.orderId);
+        if (index !== -1) {
+            MOCK_PARKED_ORDERS.splice(index, 1);
+        }
+    }
     return {
         success: true,
         orderId: params?.orderId || "",

package/dist/actions/initiate-refund/mock.js

@@ -1,5 +1,6 @@
 export const mockInitiateRefund = async (params) => {
     console.log("[Mock] initiateRefund called", params);
+    window.alert(`Demo: Initiating Refund for Order: ${params?.orderId || "Current Active Order"}\n(Refund UI would open here)`);
     return {
         success: true,
         orderId: params?.orderId || "mock_order_id",

package/dist/actions/open-cash-drawer/mock.js

@@ -1,5 +1,6 @@
 export const mockOpenCashDrawer = async () => {
     console.log("[Mock] openCashDrawer called");
+    window.alert("Demo: *Click* Cash Drawer Opened!");
     return {
         success: true,
         timestamp: new Date().toISOString()

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

@@ -1,9 +1,21 @@
-import { MOCK_ORDERS } from "../../demo/database";
+import { MOCK_PARKED_ORDERS, createOrderFromCart, MOCK_ORDERS } from "../../demo/database";
 export const mockParkOrder = async () => {
     console.log("[Mock] parkOrder called");
+    // Create a temporary order to capture cart state
+    // We use createOrderFromCart which resets the cart and pushes to MOCK_ORDERS
+    const tempOrder = createOrderFromCart("none", 0, "none");
+    // Modify to reflect parked status
+    tempOrder.status = "parked";
+    tempOrder.paymentMethods = []; // clear dummy payment
+    // Move from MOCK_ORDERS to MOCK_PARKED_ORDERS
+    const foundIndex = MOCK_ORDERS.findIndex(o => o._id === tempOrder._id);
+    if (foundIndex !== -1) {
+        MOCK_ORDERS.splice(foundIndex, 1);
+    }
+    MOCK_PARKED_ORDERS.push(tempOrder);
     return {
         success: true,
-        order: MOCK_ORDERS[0],
+        order: tempOrder,
         timestamp: new Date().toISOString()
     };
 };

package/dist/actions/partial-payment/action.js

@@ -4,5 +4,9 @@
  */
 import { commandFrameClient } from "../../client";
 export const partialPayment = async (params) => {
-    return await commandFrameClient.call("partialPayment", params);
+    const finalParams = {
+        ...params,
+        openUI: params?.openUI ?? true
+    };
+    return await commandFrameClient.call("partialPayment", finalParams);
 };

package/dist/actions/partial-payment/mock.js

@@ -1,12 +1,17 @@
 import { MOCK_ORDERS } from "../../demo/database";
 export const mockPartialPayment = async (params) => {
     console.log("[Mock] partialPayment called", params);
+    const openUI = params?.openUI ?? true;
+    if (openUI) {
+        // Simulate UI opening
+        window.alert("Demo: Split Payment UI would open here.");
+    }
     return {
         success: true,
         amount: params?.amount,
         isPercent: params?.isPercent || false,
-        openUI: params?.openUI || false,
-        order: params?.openUI ? null : MOCK_ORDERS[0],
+        openUI,
+        order: openUI ? null : MOCK_ORDERS[0],
         timestamp: new Date().toISOString()
     };
 };

package/dist/actions/remove-customer-from-cart/mock.js

@@ -1,6 +1,7 @@
 import { MOCK_CART } from "../../demo/database";
 export const mockRemoveCustomerFromCart = async () => {
     console.log("[Mock] removeCustomerFromCart called");
+    // Actually remove the customer from the mock cart
     MOCK_CART.customer = null;
     return {
         success: true,

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

@@ -1,9 +1,53 @@
-import { MOCK_ORDERS } from "../../demo/database";
+import { MOCK_PARKED_ORDERS, MOCK_CART, resetMockCart } from "../../demo/database";
 export const mockResumeParkedOrder = async (params) => {
     console.log("[Mock] resumeParkedOrder called", params);
+    const orderId = params?.orderId;
+    let orderToResume = null;
+    let index = -1;
+    if (orderId) {
+        index = MOCK_PARKED_ORDERS.findIndex(o => o._id === orderId);
+        if (index !== -1)
+            orderToResume = MOCK_PARKED_ORDERS[index];
+    }
+    else {
+        // Resume last if no ID
+        if (MOCK_PARKED_ORDERS.length > 0) {
+            index = MOCK_PARKED_ORDERS.length - 1;
+            orderToResume = MOCK_PARKED_ORDERS[index];
+        }
+    }
+    if (!orderToResume) {
+        throw new Error("Parked order not found");
+    }
+    // Restore to MOCK_CART
+    // Logic to convert Order back to Cart (simplified)
+    resetMockCart();
+    // Copy properties back
+    MOCK_CART.customer = orderToResume.customer; // Cast if needed
+    // MOCK_CART.products = orderToResume.lineItems... (Mapping needed)
+    // For Mock demo, we'll do a best effort mapping
+    MOCK_CART.products = orderToResume.lineItems.map(li => ({
+        id: li.productId,
+        name: li.name,
+        quantity: li.quantity,
+        price: parseFloat(li.price),
+        internalId: li.internalId || li.productId,
+        variantId: li.variantId,
+        sku: li.sku,
+        images: [li.image],
+        stock: 100,
+        taxTableId: "",
+        attributes: li.attributes
+    }));
+    MOCK_CART.subtotal = parseFloat(orderToResume.summary.subTotal);
+    MOCK_CART.total = parseFloat(orderToResume.summary.total);
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
+    // Remove from parked
+    MOCK_PARKED_ORDERS.splice(index, 1);
     return {
         success: true,
-        order: MOCK_ORDERS[0],
+        order: orderToResume,
         timestamp: new Date().toISOString()
     };
 };

package/dist/actions/show-confirmation/mock.js

@@ -1,6 +1,9 @@
 export const mockShowConfirmation = async (params) => {
     console.log("[Mock] showConfirmation called", params);
-    // Simulate user confirming
+    const confirmed = window.confirm(`Confirmation Required:\n${params?.message || "Are you sure?"}`);
+    if (!confirmed) {
+        throw new Error("User cancelled confirmation");
+    }
     return {
         success: true,
         message: params?.message || "",

package/dist/actions/show-notification/mock.js

@@ -1,5 +1,6 @@
 export const mockShowNotification = async (params) => {
     console.log("[Mock] showNotification called", params);
+    window.alert(`Notification: ${params?.message || "No message"}`);
     return {
         success: true,
         message: params?.message || "",

package/dist/actions/tap-to-pay-payment/mock.js

@@ -1,6 +1,8 @@
 import { MOCK_ORDERS } from "../../demo/database";
 export const mockTapToPayPayment = async (params) => {
     console.log("[Mock] tapToPayPayment called", params);
+    // Simulate Tap to Pay interaction
+    window.alert("Demo: Processing Tap to Pay...\n(Please tap card or device on screen)");
     return {
         success: true,
         amount: params?.amount || null,

package/dist/actions/terminal-payment/mock.js

@@ -1,7 +1,9 @@
-import { createOrderFromCart } from "../../demo/database";
+import { createOrderFromCart, MOCK_CART } from "../../demo/database";
 export const mockTerminalPayment = async (params) => {
     console.log("[Mock] terminalPayment called", params);
-    const amount = params?.amount || 0;
+    // Simulate terminal interaction
+    window.alert("Demo: Processing Terminal Payment...\n(Please tap, insert, or swipe card on terminal)");
+    const amount = params?.amount || MOCK_CART.total;
     // Mocking terminal payment success immediately
     const order = createOrderFromCart("card", amount, "stripe_terminal");
     return {

package/dist/demo/database.d.ts

@@ -36,6 +36,7 @@ export declare const MOCK_CUSTOMERS: CFCustomer[];
 export declare const MOCK_CATEGORIES: CFCategory[];
 export declare const MOCK_PRODUCTS: CFProduct[];
 export declare const MOCK_ORDERS: CFActiveOrder[];
+export declare const MOCK_PARKED_ORDERS: CFActiveOrder[];
 export declare const MOCK_USER: CFActiveUser;
 export declare const MOCK_STATION: CFActiveStation;
 export declare const MOCK_OUTLET: CFActiveOutlet;

package/dist/demo/database.js

@@ -403,6 +403,7 @@ export const MOCK_PRODUCTS = [
     MOCK_PRODUCT_ROASTED_TOMATO
 ];
 export const MOCK_ORDERS = [MOCK_ORDER_1, MOCK_ORDER_2];
+export const MOCK_PARKED_ORDERS = [];
 // Compatibility Exports
 export const MOCK_USER = MOCK_USERS[0];
 export const MOCK_STATION = MOCK_STATIONS[0];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@final-commerce/command-frame",
-    "version": "0.1.11",
+    "version": "0.1.12",
     "description": "Commands Frame library",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",