@final-commerce/command-frame 0.1.15 → 0.1.17

package/dist/provider.d.ts

@@ -0,0 +1,19 @@
+export type ActionHandler<TParams = any, TResponse = any> = (params: TParams) => Promise<TResponse> | TResponse;
+export type ActionHandlers = Map<string, ActionHandler>;
+export declare class CommandFrameProvider<TActions extends object = any> {
+    private handlers;
+    private origin;
+    private debug;
+    private destroyed;
+    private boundHandleMessage;
+    constructor(actions?: TActions, options?: {
+        origin?: string;
+        debug?: boolean;
+    });
+    register<TParams = any, TResponse = any>(action: string, handler: ActionHandler<TParams, TResponse>): void;
+    unregister(action: string): void;
+    private handleMessage;
+    private sendResponse;
+    destroy(): void;
+    isDestroyed(): boolean;
+}

package/dist/provider.js

@@ -0,0 +1,178 @@
+export class CommandFrameProvider {
+    constructor(actions, options = {}) {
+        this.handlers = new Map();
+        this.destroyed = false;
+        this.origin = options.origin || "*";
+        this.debug = options.debug || false;
+        this.boundHandleMessage = this.handleMessage.bind(this);
+        if (typeof window !== "undefined") {
+            window.addEventListener("message", this.boundHandleMessage);
+        }
+        if (actions) {
+            Object.keys(actions).forEach((actionName) => {
+                const handler = actions[actionName];
+                if (typeof handler === "function") {
+                    this.register(actionName, handler);
+                }
+            });
+        }
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Initialized", {
+                origin: this.origin,
+                debug: this.debug
+            });
+        }
+    }
+    register(action, handler) {
+        if (this.destroyed) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot register action after destruction", { action });
+            }
+            return;
+        }
+        this.handlers.set(action, handler);
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Registered action", { action });
+        }
+    }
+    unregister(action) {
+        if (this.destroyed) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot unregister action after destruction", { action });
+            }
+            return;
+        }
+        this.handlers.delete(action);
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Unregistered action", { action });
+        }
+    }
+    async handleMessage(event) {
+        // Ignore messages after destruction
+        if (this.destroyed) {
+            return;
+        }
+        const request = event.data;
+        if (!request || typeof request !== "object" || !("action" in request)) {
+            return;
+        }
+        if (this.origin !== "*" && event.origin !== this.origin) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Origin mismatch", {
+                    expected: this.origin,
+                    received: event.origin
+                });
+            }
+            return;
+        }
+        if (!request.action || !request.requestId) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Invalid request format", {
+                    data: event.data,
+                    origin: event.origin
+                });
+            }
+            return;
+        }
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Received request", {
+                origin: event.origin,
+                action: request.action,
+                requestId: request.requestId,
+                timestamp: new Date().toISOString()
+            });
+        }
+        const handler = this.handlers.get(request.action);
+        if (!handler) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Unknown action", { action: request.action });
+            }
+            // Only send response if source window is still available
+            if (event.source && event.source !== window) {
+                this.sendResponse(event.source, request.requestId, {
+                    success: false,
+                    error: `Unknown action: ${request.action}`
+                });
+            }
+            return;
+        }
+        try {
+            const result = await handler(request.params);
+            // Only send response if source window is still available
+            if (event.source && event.source !== window) {
+                this.sendResponse(event.source, request.requestId, {
+                    success: true,
+                    data: result
+                });
+                if (this.debug) {
+                    console.log("[CommandFrameProvider] Action executed", {
+                        action: request.action,
+                        requestId: request.requestId
+                    });
+                }
+            }
+            else if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot send response - source window unavailable", {
+                    action: request.action,
+                    requestId: request.requestId
+                });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            // Only send response if source window is still available
+            if (event.source && event.source !== window) {
+                this.sendResponse(event.source, request.requestId, {
+                    success: false,
+                    error: errorMessage
+                });
+                if (this.debug) {
+                    console.error("[CommandFrameProvider] Action failed", {
+                        action: request.action,
+                        requestId: request.requestId,
+                        error: errorMessage
+                    });
+                }
+            }
+            else if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot send error response - source window unavailable", {
+                    action: request.action,
+                    requestId: request.requestId,
+                    error: errorMessage
+                });
+            }
+        }
+    }
+    sendResponse(target, requestId, response) {
+        const message = {
+            requestId,
+            ...response
+        };
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Sending response", {
+                requestId,
+                success: response.success
+            });
+        }
+        target.postMessage(message, this.origin);
+    }
+    destroy() {
+        if (this.destroyed) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Already destroyed");
+            }
+            return;
+        }
+        this.destroyed = true;
+        this.handlers.clear();
+        if (typeof window !== "undefined") {
+            window.removeEventListener("message", this.boundHandleMessage);
+        }
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Destroyed");
+        }
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+}

package/dist/pubsub/subscriber.d.ts

@@ -11,10 +11,14 @@ export declare class TopicSubscriber {
     private useGlobalDebug;
     private boundHandleMessage;
     private subscriptionIdCounter;
+    private mockMode;
+    private detectionTimeout;
     constructor(options?: {
         origin?: string;
         debug?: boolean;
     });
+    private initDetection;
+    private switchToMockMode;
     private isDebugEnabled;
     /**
      * Request the list of available topics from the host

package/dist/pubsub/subscriber.js

@@ -2,28 +2,64 @@
  * Topic Subscriber for iframe communication
  * Manages subscriptions to topics and receives events from the host window
  */
+import { mockSubscribeToTopic } from "../demo/database";
 export class TopicSubscriber {
     constructor(options = {}) {
         this.subscriptions = new Map();
         this.topics = [];
         this.subscriptionIdCounter = 0;
+        this.mockMode = false;
         this.origin = options.origin || "*";
         this.debug = options.debug ?? false;
         this.useGlobalDebug = options.debug === undefined;
+        // Detect standalone mode (no parent iframe)
+        if (typeof window !== 'undefined' && (!window.parent || window.parent === window)) {
+            this.mockMode = true;
+            if (this.isDebugEnabled()) {
+                console.log("[TopicSubscriber] Mock Mode enabled (standalone mode detected)");
+            }
+        }
         // Store bound handler for cleanup
         this.boundHandleMessage = this.handleMessage.bind(this);
         if (typeof window !== "undefined") {
             window.addEventListener("message", this.boundHandleMessage);
         }
-        // Request topics list on initialization
-        this.requestTopics();
+        // Initialize connection detection
+        if (!this.mockMode) {
+            this.initDetection();
+            this.requestTopics();
+        }
         if (this.isDebugEnabled()) {
             console.log("[TopicSubscriber] Initialized", {
                 origin: this.origin,
-                debug: this.isDebugEnabled()
+                debug: this.isDebugEnabled(),
+                mockMode: this.mockMode
             });
         }
     }
+    initDetection() {
+        // If we don't receive any message from parent within 2 seconds, switch to mock mode
+        this.detectionTimeout = setTimeout(() => {
+            if (this.isDebugEnabled()) {
+                console.warn("[TopicSubscriber] Connection timeout. Switching to Mock Mode.");
+            }
+            this.switchToMockMode();
+        }, 2000);
+    }
+    switchToMockMode() {
+        if (this.mockMode)
+            return;
+        this.mockMode = true;
+        // Migrate existing subscriptions to mock system
+        this.subscriptions.forEach((subs, topic) => {
+            subs.forEach(sub => {
+                if (this.isDebugEnabled()) {
+                    console.log("[TopicSubscriber] Migrating subscription to mock system", { topic, id: sub.id });
+                }
+                mockSubscribeToTopic(topic, sub.callback);
+            });
+        });
+    }
     isDebugEnabled() {
         if (!this.useGlobalDebug) {
             return this.debug;
@@ -60,12 +96,19 @@ export class TopicSubscriber {
             callback: callback
         };
         this.subscriptions.get(topic).push(subscription);
-        // Notify host about the subscription
-        this.notifySubscription(topic, true);
+        // In mock mode, also register with the mock event system
+        if (this.mockMode) {
+            mockSubscribeToTopic(topic, callback);
+        }
+        else {
+            // Notify host about the subscription (only in real mode)
+            this.notifySubscription(topic, true);
+        }
         if (this.isDebugEnabled()) {
             console.log("[TopicSubscriber] Subscribed to topic", {
                 topic,
                 subscriptionId,
+                mockMode: this.mockMode,
                 totalSubscriptions: this.subscriptions.get(topic).length
             });
         }
@@ -160,6 +203,11 @@ export class TopicSubscriber {
             return;
         }
         const data = event.data;
+        // Clear detection timeout on first valid message from parent
+        if (this.detectionTimeout && data && (data.type === "pubsub-event" || data.type === "pubsub-topics-list")) {
+            clearTimeout(this.detectionTimeout);
+            this.detectionTimeout = undefined;
+        }
         // Handle topic event
         if (data && data.type === "pubsub-event") {
             const eventMessage = data;

package/dist/pubsub/topics/types.d.ts

@@ -0,0 +1,14 @@
+import { CustomersEventType, CustomersEventPayload } from "./customers/types";
+import { OrdersEventType, OrdersEventPayload } from "./orders/types";
+import { RefundsEventType, RefundsEventPayload } from "./refunds/types";
+import { ProductsEventType, ProductsEventPayload } from "./products/types";
+import { CartEventType, CartEventPayload } from "./cart/types";
+import { PaymentsEventType, PaymentsEventPayload } from "./payments/types";
+export interface TopicEventPayloadMap {
+    customers: Record<CustomersEventType, CustomersEventPayload>;
+    orders: Record<OrdersEventType, OrdersEventPayload>;
+    refunds: Record<RefundsEventType, RefundsEventPayload>;
+    products: Record<ProductsEventType, ProductsEventPayload>;
+    cart: Record<CartEventType, CartEventPayload>;
+    payments: Record<PaymentsEventType, PaymentsEventPayload>;
+}

package/dist/pubsub/topics/types.js

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

package/dist/pubsub/types.d.ts

@@ -40,3 +40,12 @@ export interface TopicSubscription {
     topic: string;
     callback: TopicSubscriptionCallback;
 }
+export interface TopicRegistration {
+    definition: TopicDefinition;
+    subscribers: {
+        iframeWindow: Window;
+        topic: string;
+        subscribedAt: number;
+        subscriptionCount: number;
+    }[];
+}

package/package.json

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

package/dist/demo/registry.d.ts

@@ -1,5 +0,0 @@
-import { command } from "../index";
-type MockHandler = (params?: any) => Promise<any>;
-export type CommandName = keyof typeof command;
-export declare const MOCK_REGISTRY: Record<CommandName, MockHandler>;
-export {};

package/dist/demo/registry.js

@@ -1,94 +0,0 @@
-import { mockAddCartDiscount } from "../actions/add-cart-discount/mock";
-import { mockAddCartFee } from "../actions/add-cart-fee/mock";
-import { mockAddCustomSale } from "../actions/add-custom-sale/mock";
-import { mockAddCustomer } from "../actions/add-customer/mock";
-import { mockAddCustomerNote } from "../actions/add-customer-note/mock";
-import { mockAddOrderNote } from "../actions/add-order-note/mock";
-import { mockAddProductDiscount } from "../actions/add-product-discount/mock";
-import { mockAddProductFee } from "../actions/add-product-fee/mock";
-import { mockAddProductNote } from "../actions/add-product-note/mock";
-import { mockAddProductToCart } from "../actions/add-product-to-cart/mock";
-import { mockAdjustInventory } from "../actions/adjust-inventory/mock";
-import { mockAssignCustomer } from "../actions/assign-customer/mock";
-import { mockAuthenticateUser } from "../actions/authenticate-user/mock";
-import { mockCalculateRefundTotal } from "../actions/calculate-refund-total/mock";
-import { mockCashPayment } from "../actions/cash-payment/mock";
-import { mockClearCart } from "../actions/clear-cart/mock";
-import { mockDeleteParkedOrder } from "../actions/delete-parked-order/mock";
-import { mockExampleFunction } from "../actions/example-function/mock";
-import { mockGetCategories } from "../actions/get-categories/mock";
-import { mockGetContext } from "../actions/get-context/mock";
-import { mockGetCurrentCart } from "../actions/get-current-cart/mock";
-import { mockGetCustomers } from "../actions/get-customers/mock";
-import { mockGetOrders } from "../actions/get-orders/mock";
-import { mockGetProducts } from "../actions/get-products/mock";
-import { mockGetRefunds } from "../actions/get-refunds/mock";
-import { mockGetRemainingRefundableQuantities } from "../actions/get-remaining-refundable-quantities/mock";
-import { mockGoToStationHome } from "../actions/go-to-station-home/mock";
-import { mockInitiateRefund } from "../actions/initiate-refund/mock";
-import { mockOpenCashDrawer } from "../actions/open-cash-drawer/mock";
-import { mockParkOrder } from "../actions/park-order/mock";
-import { mockPartialPayment } from "../actions/partial-payment/mock";
-import { mockProcessPartialRefund } from "../actions/process-partial-refund/mock";
-import { mockRemoveCustomerFromCart } from "../actions/remove-customer-from-cart/mock";
-import { mockResetRefundDetails } from "../actions/reset-refund-details/mock";
-import { mockResumeParkedOrder } from "../actions/resume-parked-order/mock";
-import { mockSelectAllRefundItems } from "../actions/select-all-refund-items/mock";
-import { mockSetRefundStockAction } from "../actions/set-refund-stock-action/mock";
-import { mockShowConfirmation } from "../actions/show-confirmation/mock";
-import { mockShowNotification } from "../actions/show-notification/mock";
-import { mockSwitchUser } from "../actions/switch-user/mock";
-import { mockTapToPayPayment } from "../actions/tap-to-pay-payment/mock";
-import { mockTerminalPayment } from "../actions/terminal-payment/mock";
-import { mockTriggerWebhook } from "../actions/trigger-webhook/mock";
-import { mockTriggerZapierWebhook } from "../actions/trigger-zapier-webhook/mock";
-import { mockVendaraPayment } from "../actions/vendara-payment/mock";
-import { mockGetFinalContext } from "../actions/get-final-context/mock";
-export const MOCK_REGISTRY = {
-    "addCartDiscount": mockAddCartDiscount,
-    "addCartFee": mockAddCartFee,
-    "addCustomSale": mockAddCustomSale,
-    "addCustomer": mockAddCustomer,
-    "addCustomerNote": mockAddCustomerNote,
-    "addOrderNote": mockAddOrderNote,
-    "addProductDiscount": mockAddProductDiscount,
-    "addProductFee": mockAddProductFee,
-    "addProductNote": mockAddProductNote,
-    "addProductToCart": mockAddProductToCart,
-    "adjustInventory": mockAdjustInventory,
-    "assignCustomer": mockAssignCustomer,
-    "authenticateUser": mockAuthenticateUser,
-    "calculateRefundTotal": mockCalculateRefundTotal,
-    "cashPayment": mockCashPayment,
-    "clearCart": mockClearCart,
-    "deleteParkedOrder": mockDeleteParkedOrder,
-    "exampleFunction": mockExampleFunction,
-    "getCategories": mockGetCategories,
-    "getContext": mockGetContext,
-    "getCurrentCart": mockGetCurrentCart,
-    "getCustomers": mockGetCustomers,
-    "getOrders": mockGetOrders,
-    "getProducts": mockGetProducts,
-    "getRefunds": mockGetRefunds,
-    "getRemainingRefundableQuantities": mockGetRemainingRefundableQuantities,
-    "goToStationHome": mockGoToStationHome,
-    "initiateRefund": mockInitiateRefund,
-    "openCashDrawer": mockOpenCashDrawer,
-    "parkOrder": mockParkOrder,
-    "partialPayment": mockPartialPayment,
-    "processPartialRefund": mockProcessPartialRefund,
-    "removeCustomerFromCart": mockRemoveCustomerFromCart,
-    "resetRefundDetails": mockResetRefundDetails,
-    "resumeParkedOrder": mockResumeParkedOrder,
-    "selectAllRefundItems": mockSelectAllRefundItems,
-    "setRefundStockAction": mockSetRefundStockAction,
-    "showConfirmation": mockShowConfirmation,
-    "showNotification": mockShowNotification,
-    "switchUser": mockSwitchUser,
-    "tapToPayPayment": mockTapToPayPayment,
-    "terminalPayment": mockTerminalPayment,
-    "triggerWebhook": mockTriggerWebhook,
-    "triggerZapierWebhook": mockTriggerZapierWebhook,
-    "vendaraPayment": mockVendaraPayment,
-    "getFinalContext": mockGetFinalContext,
-};