@final-commerce/command-frame 0.0.1 → 0.0.4

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

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

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

@@ -0,0 +1,12 @@
+export const mockAddCustomSale = async (params) => {
+    console.log("[Mock] addCustomSale called", params);
+    if (!params)
+        throw new Error("Params required");
+    return {
+        success: true,
+        label: params.label,
+        price: Number(params.price),
+        applyTaxes: params.applyTaxes ?? false,
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/add-customer/mock.d.ts

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

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

@@ -0,0 +1,23 @@
+import { MOCK_CUSTOMERS } from "../../demo/database";
+export const mockAddCustomer = async (params) => {
+    console.log("[Mock] addCustomer called", params);
+    if (!params?.customer)
+        throw new Error("Customer data required");
+    const newCustomer = {
+        _id: "new_mock_cust_" + Date.now(),
+        companyId: "mock_company_id",
+        email: params.customer.email || "",
+        firstName: params.customer.firstName || "",
+        lastName: params.customer.lastName || "",
+        phone: params.customer.phone,
+        billing: null,
+        shipping: null,
+        ...params.customer
+    };
+    MOCK_CUSTOMERS.push(newCustomer);
+    return {
+        success: true,
+        customer: newCustomer,
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/add-customer/types.d.ts

@@ -1,9 +1,10 @@
+import { CFCustomer } from "../../CommonTypes";
 export interface AddCustomerParams {
-    customer: Record<string, any>;
+    customer: Partial<CFCustomer>;
 }
 export interface AddCustomerResponse {
     success: boolean;
-    customer: any;
+    customer: CFCustomer;
     timestamp: string;
 }
 export type AddCustomer = (params: AddCustomerParams) => Promise<AddCustomerResponse>;

package/dist/actions/add-customer-note/mock.d.ts

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

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

@@ -0,0 +1,9 @@
+export const mockAddCustomerNote = async (params) => {
+    console.log("[Mock] addCustomerNote called", params);
+    return {
+        success: true,
+        customerId: params?.customerId || "",
+        note: params?.note || "",
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/add-order-note/mock.d.ts

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

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

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

package/dist/actions/add-product-discount/mock.d.ts

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

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

@@ -0,0 +1,10 @@
+export const mockAddProductDiscount = async (params) => {
+    console.log("[Mock] addProductDiscount called", params);
+    return {
+        success: true,
+        amount: params?.amount || 0,
+        isPercent: params?.isPercent || false,
+        label: params?.label || "",
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/add-product-fee/mock.d.ts

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

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

@@ -0,0 +1,11 @@
+export const mockAddProductFee = async (params) => {
+    console.log("[Mock] addProductFee called", params);
+    return {
+        success: true,
+        amount: params?.amount || 0,
+        isPercent: params?.isPercent || false,
+        label: params?.label || "",
+        applyTaxes: params?.applyTaxes || false,
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/add-product-note/mock.d.ts

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

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

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

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

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

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

@@ -0,0 +1,56 @@
+import { MOCK_CART, MOCK_PRODUCTS } from "../../demo/database";
+export const mockAddProductToCart = async (params) => {
+    console.log("[Mock] addProductToCart called", params);
+    const productId = params?.productId;
+    const variantId = params?.variantId;
+    const quantity = params?.quantity || 1;
+    let product = MOCK_PRODUCTS[0]; // Default fallback
+    if (productId) {
+        const found = MOCK_PRODUCTS.find(p => p._id === productId);
+        if (found) {
+            product = found;
+        }
+        else {
+            console.warn(`[Mock] Product with ID ${productId} not found, using default.`);
+        }
+    }
+    // Determine variant
+    let variant = product.variants[0];
+    if (variantId) {
+        const foundVariant = product.variants.find(v => v._id === variantId);
+        if (foundVariant) {
+            variant = foundVariant;
+        }
+    }
+    // Add to MOCK_CART
+    const activeProduct = {
+        ...product,
+        id: product._id,
+        internalId: product._id + "_" + Date.now(), // unique ID for cart item
+        variantId: variant._id,
+        quantity: quantity,
+        price: Number(variant.price),
+        taxTableId: product.taxTable,
+        stock: variant.inventory?.[0]?.stock || 0,
+        images: product.images || [],
+        localQuantity: quantity,
+        sku: variant.sku,
+        attributes: variant.attributes.map(a => `${a.name}: ${a.value}`).join(", ")
+    };
+    MOCK_CART.products.push(activeProduct);
+    // Recalculate totals
+    const lineTotal = activeProduct.price * quantity;
+    MOCK_CART.subtotal += lineTotal;
+    // Simple total calculation (ignoring taxes/fees for mock simplicity unless needed)
+    MOCK_CART.total += lineTotal;
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
+    return {
+        success: true,
+        productId: activeProduct.id,
+        variantId: activeProduct.variantId,
+        name: activeProduct.name,
+        quantity: quantity,
+        timestamp: new Date().toISOString()
+    };
+};

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

@@ -1,4 +1,6 @@
 export interface AddProductToCartParams {
+    productId?: string;
+    variantId?: string;
     quantity?: number;
 }
 export interface AddProductToCartResponse {

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

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

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

@@ -0,0 +1,18 @@
+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);
+    return {
+        success: true,
+        amount: params?.amount || "0",
+        stockType: params?.stockType || "set",
+        newStock,
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/assign-customer/mock.d.ts

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

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

@@ -0,0 +1,14 @@
+import { MOCK_CUSTOMERS, MOCK_CART } from "../../demo/database";
+export const mockAssignCustomer = async (params) => {
+    console.log("[Mock] assignCustomer called", params);
+    const customer = MOCK_CUSTOMERS.find(c => c._id === params.customerId);
+    if (!customer) {
+        throw new Error("Customer not found in mock DB");
+    }
+    MOCK_CART.customer = customer;
+    return {
+        success: true,
+        customer,
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/assign-customer/types.d.ts

@@ -1,9 +1,10 @@
+import { CFCustomer } from "../../CommonTypes";
 export interface AssignCustomerParams {
     customerId: string;
 }
 export interface AssignCustomerResponse {
     success: boolean;
-    customer: any;
+    customer: CFCustomer;
     timestamp: string;
 }
 export type AssignCustomer = (params: AssignCustomerParams) => Promise<AssignCustomerResponse>;

package/dist/actions/authenticate-user/mock.d.ts

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

package/dist/actions/authenticate-user/mock.js

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

package/dist/actions/calculate-refund-total/mock.d.ts

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

package/dist/actions/calculate-refund-total/mock.js

@@ -0,0 +1,14 @@
+export const mockCalculateRefundTotal = async () => {
+    console.log("[Mock] calculateRefundTotal called");
+    return {
+        success: true,
+        summary: {
+            subtotal: "0.00",
+            tax: "0.00",
+            total: "0.00"
+        },
+        refundedLineItems: [],
+        refundedCustomSales: [],
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/calculate-refund-total/types.d.ts

@@ -1,3 +1,4 @@
+import { CFRefundedLineItem, CFRefundedCustomSale } from "../../CommonTypes";
 export interface CalculateRefundTotalResponse {
     success: boolean;
     summary: {
@@ -5,8 +6,8 @@ export interface CalculateRefundTotalResponse {
         tax: string;
         total: string;
     };
-    refundedLineItems: any[];
-    refundedCustomSales: any[];
+    refundedLineItems: CFRefundedLineItem[];
+    refundedCustomSales: CFRefundedCustomSale[];
     timestamp: string;
 }
 export type CalculateRefundTotal = () => Promise<CalculateRefundTotalResponse>;

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

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

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

@@ -0,0 +1,14 @@
+import { createOrderFromCart } from "../../demo/database";
+export const mockCashPayment = async (params) => {
+    console.log("[Mock] cashPayment called", params);
+    const amount = params?.amount || 0;
+    const order = createOrderFromCart("cash", amount, "cash");
+    return {
+        success: true,
+        amount,
+        openChangeCalculator: params?.openChangeCalculator || false,
+        paymentType: "cash",
+        order,
+        timestamp: new Date().toISOString()
+    };
+};

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

@@ -1,3 +1,4 @@
+import { CFOrder } from "../../CommonTypes";
 export interface CashPaymentParams {
     amount?: number;
     openChangeCalculator?: boolean;
@@ -7,7 +8,7 @@ export interface CashPaymentResponse {
     amount: number;
     openChangeCalculator: boolean;
     paymentType: string;
-    order: any | null;
+    order: CFOrder | null;
     timestamp: string;
 }
 export type CashPayment = (params?: CashPaymentParams) => Promise<CashPaymentResponse>;

package/dist/actions/clear-cart/mock.d.ts

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

package/dist/actions/clear-cart/mock.js

@@ -0,0 +1,9 @@
+import { resetMockCart } from "../../demo/database";
+export const mockClearCart = async () => {
+    console.log("[Mock] clearCart called");
+    resetMockCart();
+    return {
+        success: true,
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/delete-parked-order/mock.d.ts

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

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

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

package/dist/actions/example-function/mock.d.ts

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

package/dist/actions/example-function/mock.js

@@ -0,0 +1,13 @@
+export const mockExampleFunction = async (params) => {
+    console.log("[Mock] exampleFunction called", params);
+    return {
+        receivedParams: params || {},
+        responsePayload: {
+            field1: "mock1",
+            field2: "mock2",
+            field3: "mock3"
+        },
+        timestamp: new Date().toISOString(),
+        processed: true
+    };
+};

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

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

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

@@ -0,0 +1,20 @@
+import { MOCK_CATEGORIES, safeSerialize } from "../../demo/database";
+export const mockGetCategories = async (params) => {
+    console.log("[Mock] getCategories called", params);
+    // Simple filter simulation
+    let categories = MOCK_CATEGORIES;
+    const query = params?.query || {};
+    if (query.name) {
+        const nameFilter = typeof query.name === 'string' ? query.name : '';
+        if (nameFilter) {
+            categories = categories.filter(c => c.name.toLowerCase().includes(nameFilter.toLowerCase()));
+        }
+    }
+    if (query.parentId !== undefined) {
+        categories = categories.filter(c => c.parentId === query.parentId);
+    }
+    return {
+        categories: safeSerialize(categories),
+        timestamp: new Date().toISOString()
+    };
+};

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

@@ -1,3 +1,4 @@
+import { CFCategory } from "../../CommonTypes";
 export interface GetCategoriesParams {
     query?: {
         name?: string | {
@@ -10,7 +11,7 @@ export interface GetCategoriesParams {
     };
 }
 export interface GetCategoriesResponse {
-    categories: any[];
+    categories: CFCategory[];
     timestamp: string;
 }
 export type GetCategories = (params?: GetCategoriesParams) => Promise<GetCategoriesResponse>;

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

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

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

@@ -0,0 +1,24 @@
+import { MOCK_COMPANY, MOCK_OUTLET, MOCK_STATION, MOCK_USER } from "../../demo/database";
+export const mockGetContext = async () => {
+    console.log("[Mock] getContext called");
+    return {
+        userId: MOCK_USER.id,
+        companyId: MOCK_COMPANY.id || null,
+        companyName: MOCK_COMPANY.name || null,
+        deviceId: "mock_device_id",
+        stationId: MOCK_STATION._id,
+        stationName: MOCK_STATION.name,
+        outletId: MOCK_OUTLET.id,
+        outletName: MOCK_OUTLET.name || null,
+        buildId: "mock_build_id",
+        buildName: "Mock Build",
+        buildVersion: "1.0.0-mock",
+        buildSourceId: "mock_source_id",
+        buildIsPremium: true,
+        user: null,
+        company: null,
+        station: null,
+        outlet: null,
+        timestamp: new Date().toISOString()
+    };
+};

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

@@ -1,17 +1,3 @@
-export interface GetContextResponse {
-    userId: string | null;
-    companyId: string | null;
-    companyName: string | null;
-    deviceId: string | null;
-    stationId: string | null;
-    stationName: string | null;
-    outletId: string | null;
-    outletName: string | null;
-    buildId: string | null;
-    buildName: string | null;
-    buildVersion: string | null;
-    buildSourceId: string | null;
-    buildIsPremium: boolean;
-    timestamp: string;
-}
+import { CFContext } from "../../CommonTypes";
+export type GetContextResponse = CFContext;
 export type GetContext = () => Promise<GetContextResponse>;

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

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

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

@@ -0,0 +1,9 @@
+import { MOCK_CART, safeSerialize } from "../../demo/database";
+export const mockGetCurrentCart = async () => {
+    console.log("[Mock] getCurrentCart called");
+    return {
+        success: true,
+        cart: safeSerialize(MOCK_CART),
+        timestamp: new Date().toISOString()
+    };
+};

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

@@ -1,6 +1,7 @@
+import { CFActiveCart } from "../../CommonTypes";
 export interface GetCurrentCartResponse {
     success: boolean;
-    cart: any;
+    cart: CFActiveCart;
     timestamp: string;
 }
 export type GetCurrentCart = () => Promise<GetCurrentCartResponse>;

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

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

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

@@ -0,0 +1,17 @@
+import { MOCK_CUSTOMERS, safeSerialize } from "../../demo/database";
+export const mockGetCustomers = async (params) => {
+    console.log("[Mock] getCustomers called", params);
+    let customers = MOCK_CUSTOMERS;
+    const query = params?.query || {};
+    if (query.searchValue) {
+        const search = String(query.searchValue).toLowerCase();
+        customers = customers.filter(c => c.firstName.toLowerCase().includes(search) ||
+            c.lastName.toLowerCase().includes(search) ||
+            c.email.toLowerCase().includes(search));
+    }
+    return {
+        customers: safeSerialize(customers),
+        total: customers.length,
+        timestamp: new Date().toISOString()
+    };
+};

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

@@ -1,3 +1,4 @@
+import { CFCustomer } from "../../CommonTypes";
 export interface GetCustomersParams {
     query?: {
         email?: string | {
@@ -24,7 +25,7 @@ export interface GetCustomersParams {
     };
 }
 export interface GetCustomersResponse {
-    customers: any[];
+    customers: CFCustomer[];
     total?: number;
     timestamp: string;
 }

package/dist/actions/get-final-context/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get final context action
+ * Calls the getFinalContext action on the parent window
+ */
+import type { GetFinalContext } from "./types";
+export declare const getFinalContext: GetFinalContext;

package/dist/actions/get-final-context/action.js

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

package/dist/actions/get-final-context/types.d.ts

@@ -0,0 +1,4 @@
+export interface GetFinalContextResponse {
+    projectName: string;
+}
+export type GetFinalContext = () => Promise<GetFinalContextResponse | null>;

package/dist/actions/get-final-context/types.js

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

package/dist/actions/get-line-items-by-order/mock.d.ts

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

package/dist/actions/get-line-items-by-order/mock.js

@@ -0,0 +1,12 @@
+export const mockGetLineItemsByOrder = async (params) => {
+    console.log("[Mock] getLineItemsByOrder called", params);
+    return {
+        success: true,
+        orderId: params?.orderId || "mock_order_id",
+        lineItems: [],
+        customSales: [],
+        remainingQuantities: {},
+        remainingCustomSalesQuantities: {},
+        timestamp: new Date().toISOString()
+    };
+};

package/dist/actions/get-line-items-by-order/types.d.ts

@@ -1,11 +1,12 @@
+import { CFLineItem, CFCustomSale } from "../../CommonTypes";
 export interface GetLineItemsByOrderParams {
     orderId?: string;
 }
 export interface GetLineItemsByOrderResponse {
     success: boolean;
     orderId: string;
-    lineItems: any[];
-    customSales: any[];
+    lineItems: CFLineItem[];
+    customSales: CFCustomSale[];
     remainingQuantities: Record<string, number>;
     remainingCustomSalesQuantities: Record<string, number>;
     timestamp: string;

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

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