@final-commerce/command-frame 0.0.1 → 0.0.4

package/dist/actions/update-customer-facing-display/mock.d.ts

@@ -0,0 +1,2 @@
+import { UpdateCustomerFacingDisplay } from "./types";
+export declare const mockUpdateCustomerFacingDisplay: UpdateCustomerFacingDisplay;

package/dist/actions/update-customer-facing-display/mock.js

@@ -0,0 +1,8 @@
+export const mockUpdateCustomerFacingDisplay = async (params) => {
+    console.log("[Mock] updateCustomerFacingDisplay called", params);
+    return {
+        success: true,
+        pageId: params?.pageId || "",
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/vendara-payment/mock.d.ts

@@ -0,0 +1,2 @@
+import { VendaraPayment } from "./types";
+export declare const mockVendaraPayment: VendaraPayment;

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

@@ -0,0 +1,11 @@
+import { MOCK_ORDERS } from "../../demo/database";
+export const mockVendaraPayment = async (params) => {
+    console.log("[Mock] vendaraPayment called", params);
+    return {
+        success: true,
+        amount: params?.amount || null,
+        paymentType: "vendara",
+        order: MOCK_ORDERS[0],
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/vendara-payment/types.d.ts

@@ -1,3 +1,4 @@
+import { CFOrder } from "../../CommonTypes";
 export interface VendaraPaymentParams {
     amount?: number;
 }
@@ -5,7 +6,7 @@ export interface VendaraPaymentResponse {
     success: boolean;
     amount: number | null;
     paymentType: string;
-    order: any | null;
+    order: CFOrder | null;
     timestamp: string;
 }
 export type VendaraPayment = (params?: VendaraPaymentParams) => Promise<VendaraPaymentResponse>;

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 /**
- * Commands Frame Client for iframe communication
+ * Command Frame Client for iframe communication
  * Allows the iframe to call functions on the parent window via postMessage
  */
 export interface PostMessageRequest<T = any> {
@@ -19,13 +19,16 @@ export declare class CommandFrameClient {
     private origin;
     private debug;
     private useGlobalDebug;
+    private mockMode;
     constructor(options?: {
         timeout?: number;
         origin?: string;
         debug?: boolean;
+        mockMode?: boolean;
     });
     private isDebugEnabled;
     call<TParams = any, TResponse = any>(action: string, params?: TParams, timeout?: number): Promise<TResponse>;
+    private getFinalContext;
     private handleMessage;
     private generateRequestId;
     destroy(): void;

package/dist/client.js

@@ -1,7 +1,8 @@
 /**
- * Commands Frame Client for iframe communication
+ * Command Frame Client for iframe communication
  * Allows the iframe to call functions on the parent window via postMessage
  */
+import { MOCK_REGISTRY } from "./demo/registry";
 export class CommandFrameClient {
     constructor(options = {}) {
         this.pendingRequests = new Map();
@@ -9,13 +10,25 @@ export class CommandFrameClient {
         this.origin = options.origin || "*";
         this.debug = options.debug ?? false;
         this.useGlobalDebug = options.debug === undefined;
+        // Default to provided mockMode or false. Detection happens via getFinalContext.
+        this.mockMode = options.mockMode ?? false;
         if (typeof window !== 'undefined') {
             window.addEventListener("message", this.handleMessage.bind(this));
         }
+        // Auto-detect mock mode on initialization
+        this.getFinalContext().then((context) => {
+            if (!context) {
+                if (this.isDebugEnabled()) {
+                    console.warn("[ActionsClient] Environment detection failed (timeout or error). Switching to Mock Mode.");
+                }
+                this.mockMode = true;
+            }
+        });
         if (this.isDebugEnabled()) {
             console.log("[ActionsClient] Initialized", {
                 origin: this.origin,
-                debug: this.isDebugEnabled()
+                debug: this.isDebugEnabled(),
+                mockMode: this.mockMode
             });
         }
     }
@@ -26,6 +39,29 @@ export class CommandFrameClient {
         return typeof window !== "undefined" && window.__POSTMESSAGE_DEBUG__ === true;
     }
     async call(action, params, timeout) {
+        // Mock Mode Handler
+        if (this.mockMode) {
+            if (this.isDebugEnabled()) {
+                console.log("[ActionsClient] Mock Call", { action, params });
+            }
+            const mockHandler = MOCK_REGISTRY[action];
+            if (mockHandler) {
+                // Simulate async delay
+                await new Promise(resolve => setTimeout(resolve, 100));
+                try {
+                    return await mockHandler(params);
+                }
+                catch (error) {
+                    console.error(`[ActionsClient] Mock Error for ${action}:`, error);
+                    throw error;
+                }
+            }
+            else {
+                console.warn(`[ActionsClient] No mock handler found for action: ${action}`);
+                throw new Error(`Mock handler not implemented for: ${action}`);
+            }
+        }
+        // Standard PostMessage Handler
         return new Promise((resolve, reject) => {
             const requestId = this.generateRequestId();
             const timeoutMs = timeout || this.defaultTimeout;
@@ -74,6 +110,31 @@ export class CommandFrameClient {
             }
         });
     }
+    // Private check to determine environment
+    getFinalContext() {
+        return new Promise((resolve) => {
+            if (typeof window === 'undefined' || !window.parent || window.parent === window)
+                return resolve(null);
+            const requestId = this.generateRequestId();
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                resolve(null);
+            }, 2000);
+            this.pendingRequests.set(requestId, {
+                resolve: (val) => { clearTimeout(timeout); resolve(val); },
+                reject: () => { clearTimeout(timeout); resolve(null); },
+                timeout
+            });
+            try {
+                window.parent.postMessage({ action: "getFinalContext", requestId }, this.origin);
+            }
+            catch {
+                clearTimeout(timeout);
+                this.pendingRequests.delete(requestId);
+                resolve(null);
+            }
+        });
+    }
     handleMessage(event) {
         if (this.isDebugEnabled()) {
             console.log("[ActionsClient] Received message", {

package/dist/demo/database.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Mock Database for Standalone/Demo Mode
+ * Stores mock data that mimics the Render environment
+ */
+import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFActiveCart, CFCategory } from "../CommonTypes";
+export declare const MOCK_COMPANY: CFActiveCompany;
+export declare const MOCK_OUTLET_MAIN: CFActiveOutlet;
+export declare const MOCK_STATION_1: CFActiveStation;
+export declare const MOCK_STATION_2: CFActiveStation;
+export declare const MOCK_USER_MARIO: CFActiveUser;
+export declare const MOCK_USER_LUIGI: CFActiveUser;
+export declare const MOCK_CUSTOMER_1: CFCustomer;
+export declare const MOCK_CUSTOMER_2: CFCustomer;
+export declare const MOCK_CUSTOMER_3: CFCustomer;
+export declare const MOCK_CUSTOMER_4: CFCustomer;
+export declare const MOCK_CUSTOMER_5: CFCustomer;
+export declare const MOCK_CATEGORY_PASTES: CFCategory;
+export declare const MOCK_CATEGORY_SPECIALTY: CFCategory;
+export declare const MOCK_CATEGORY_BASIC: CFCategory;
+export declare const MOCK_PRODUCT_BASIL_ALMOND: CFProduct;
+export declare const MOCK_PRODUCT_BEER: CFProduct;
+export declare const MOCK_PRODUCT_BEET: CFProduct;
+export declare const MOCK_PRODUCT_CARAMELIZED: CFProduct;
+export declare const MOCK_PRODUCT_GARLIC_ONION: CFProduct;
+export declare const MOCK_PRODUCT_GARLIC: CFProduct;
+export declare const MOCK_PRODUCT_GINGER_LIME: CFProduct;
+export declare const MOCK_PRODUCT_LEMON: CFProduct;
+export declare const MOCK_PRODUCT_RED_PEPPER: CFProduct;
+export declare const MOCK_PRODUCT_ROASTED_TOMATO: CFProduct;
+export declare const MOCK_ORDER_1: CFActiveOrder;
+export declare const MOCK_ORDER_2: CFActiveOrder;
+export declare const MOCK_USERS: CFActiveUser[];
+export declare const MOCK_STATIONS: CFActiveStation[];
+export declare const MOCK_OUTLETS: CFActiveOutlet[];
+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_USER: CFActiveUser;
+export declare const MOCK_STATION: CFActiveStation;
+export declare const MOCK_OUTLET: CFActiveOutlet;
+export declare let MOCK_CART: CFActiveCart;
+export declare const resetMockCart: () => void;
+export declare const safeSerialize: <T>(data: T) => T;
+export declare const createOrderFromCart: (paymentType: string, amount: number | string, processor?: string) => CFActiveOrder;