@final-commerce/command-frame 0.9.0 → 0.10.0-staging.2

package/dist/actions/get-composite-availability/types.d.ts

@@ -0,0 +1,29 @@
+import type { CFCompositePick } from '../../CommonTypes';
+export interface GetCompositeAvailabilityParams {
+    /** The composite's variant — the one `addProductToCart` takes. Its `composite.needsDate` is true. */
+    variantId: string;
+    /** The picks so far; their bookable items decide the seats asked. Absent = each part's `defaultPick`. */
+    composite?: CFCompositePick[];
+    /** First shop day, `YYYY-MM-DD` in the shop's zone. Defaults to today. */
+    fromDay?: string;
+    /** How many shop days from `fromDay`. Defaults to 1. */
+    days?: number;
+}
+/** A start every bookable of the composite can be held at, with the seats its picks need. */
+export interface CFCompositeSlot {
+    /** ISO 8601 — send it back as `addProductToCart({ compositeSlot: { startAt } })`. */
+    startAt: string;
+    /** The shop day it falls on, `YYYY-MM-DD` — what a day picker groups by. */
+    dayKey: string;
+}
+export interface GetCompositeAvailabilityResponse {
+    /** False when the host refused: not a composite, nothing bookable picked, no booking rules on this till yet. */
+    success: boolean;
+    reason?: string;
+    /** In time order. Empty = nothing free for all of them in those days. */
+    slots: CFCompositeSlot[];
+    /** The clock `startAt` and `dayKey` read on; null when no bookable serves here. */
+    timeZone: string | null;
+    timestamp: string;
+}
+export type GetCompositeAvailability = (params: GetCompositeAvailabilityParams) => Promise<GetCompositeAvailabilityResponse>;

package/dist/actions/get-composite-availability/types.js

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

package/dist/actions/get-composite-price/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get composite price action (read-only)
+ * Calls the getCompositePrice action on the parent window
+ */
+import type { GetCompositePrice } from './types';
+export declare const getCompositePrice: GetCompositePrice;

package/dist/actions/get-composite-price/action.js

@@ -0,0 +1,8 @@
+/**
+ * Get composite price action (read-only)
+ * Calls the getCompositePrice action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const getCompositePrice = async (params) => {
+    return await commandFrameClient.call('getCompositePrice', params);
+};

package/dist/actions/get-composite-price/mock.d.ts

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

package/dist/actions/get-composite-price/mock.js

@@ -0,0 +1,37 @@
+import { MOCK_CART, MOCK_PRODUCTS, buildModifierRows, mockCompositeAtOutlet, mockCompositeStockRefusal, mockHiddenProductIds, } from '../../demo/database';
+import { compositePicksRefusal, mockCompositeLine, mockNeedsDateRefusal, mockPicksStillNeeded, } from '../add-product-to-cart/mock';
+// The same line the mock addProductToCart builds, priced for ONE composite and added to nothing.
+export const mockGetCompositePrice = async (params) => {
+    console.log('[Mock] getCompositePrice called', params);
+    const timestamp = new Date().toISOString();
+    const product = MOCK_PRODUCTS.find((candidate) => candidate.variants.some((v) => v._id === params?.variantId));
+    if (!product)
+        throw new Error(`Variant with ID ${params?.variantId} not found`);
+    if (!product.composite) {
+        return {
+            success: false,
+            reason: `${product.name} is not a composite: it takes no composite picks`,
+            missing: [],
+            timestamp,
+        };
+    }
+    const picks = params.composite ?? [];
+    // What this outlet sells (the host's catalog-visibility rules).
+    const composite = mockCompositeAtOutlet(product.composite, undefined, params.compositeSlot);
+    const missing = mockPicksStillNeeded(composite, picks);
+    if (mockHiddenProductIds().has(product._id)) {
+        return { success: false, reason: `${product.name} is not sold at this outlet`, missing, timestamp };
+    }
+    const line = mockNeedsDateRefusal(product.name, composite, params.compositeSlot) ??
+        compositePicksRefusal(composite, picks) ??
+        mockCompositeLine(composite, picks, !product.taxTable);
+    if (typeof line === 'string')
+        return { success: false, reason: line, missing, timestamp };
+    const shortOfStock = mockCompositeStockRefusal([
+        ...MOCK_CART.products,
+        { variantId: params.variantId, quantity: 1, components: line.components },
+    ]);
+    if (shortOfStock)
+        return { success: false, reason: shortOfStock, missing, timestamp };
+    return { success: true, total: line.price + buildModifierRows(line.modifiers, 1).modifiersTotal, missing, timestamp };
+};

package/dist/actions/get-composite-price/types.d.ts

@@ -0,0 +1,31 @@
+import type { CFCompositePick } from '../../CommonTypes';
+export interface GetCompositePriceParams {
+    /** The composite's variant — the one `addProductToCart` takes. */
+    variantId: string;
+    /** The picks so far, exactly as `addProductToCart({ composite })` would send them. */
+    composite: CFCompositePick[];
+    /** B41: the date and time a bookable pick is for, as `addProductToCart` takes it; without one a bookable pick is refused. */
+    compositeSlot?: {
+        startAt: string;
+    };
+}
+export interface GetCompositePriceResponse {
+    success: boolean;
+    /** Why these picks are refused — the same refusal and text `addProductToCart` would give. */
+    reason?: string;
+    /**
+     * What ONE composite with these picks adds to the cart, minor units: the line price the host would build plus the
+     * picked items' modifiers. Before discounts, fees and tax. Show it; do not recompute it. Absent when refused.
+     */
+    total?: number;
+    /**
+     * The parts that still need picks before the composite can be added, and how many ("Pick 2 more"); empty when every
+     * required part is filled. Decided by the host — keep Add to cart disabled while this is not empty.
+     */
+    missing: {
+        partId: string;
+        needed: number;
+    }[];
+    timestamp: string;
+}
+export type GetCompositePrice = (params: GetCompositePriceParams) => Promise<GetCompositePriceResponse>;

package/dist/actions/get-composite-price/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,19 @@
-import { MOCK_CART, safeSerialize } from "../../demo/database";
+import { MOCK_CART, buildModifierRows, safeSerialize } from '../../demo/database';
+import { extendPrice } from '@final-commerce/common';
 export const mockGetCurrentCart = async () => {
-    console.log("[Mock] getCurrentCart called");
+    console.log('[Mock] getCurrentCart called');
+    // The mock keeps no discounts or fees per line: a line is its price × quantity plus its modifier rows.
+    const lineTotals = Object.fromEntries([
+        ...MOCK_CART.products.map((line) => [
+            line.internalId ?? line.id,
+            extendPrice(line.price, line.quantity) + buildModifierRows(line.modifiers, line.quantity).modifiersTotal,
+        ]),
+        ...(MOCK_CART.customSales ?? []).map((sale) => [sale.id, extendPrice(sale.price, sale.quantity)]),
+    ]);
     return {
         success: true,
         cart: safeSerialize(MOCK_CART),
-        timestamp: new Date().toISOString()
+        lineTotals,
+        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;
+    /**
+     * What each line adds to the cart, minor units, keyed by the line's `internalId` (products, bookings) or `id`
+     * (custom sales): price × quantity − its own discounts + its own fees + its modifiers. Before the cart discount
+     * and tax; Σ = the cart's subtotal before non-revenue items. Show it; do not recompute it.
+     */
+    lineTotals?: Record<string, number>;
     timestamp: string;
 }
 export type GetCurrentCart = () => Promise<GetCurrentCartResponse>;

package/dist/actions/get-product-modifier-selections/mock.js

@@ -16,6 +16,18 @@ export const mockGetProductModifierSelections = async (params) => {
             timestamp: new Date().toISOString(),
         };
     }
+    // Like the host (FT-83): a composite line's modifiers belong to its components.
+    if (line.components?.length) {
+        return {
+            success: false,
+            reason: 'The modifiers of a composite line cannot be edited yet: remove the line and add it again with its picks',
+            internalId: line.internalId,
+            selections: [],
+            rows: [],
+            modifiersTotal: 0,
+            timestamp: new Date().toISOString(),
+        };
+    }
     // The priced rows already sit on the line; extending them by the line quantity is
     // the host's job, not the flow's.
     const { rows, modifiersTotal } = buildModifierRows(line.modifiers, line.quantity);

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

@@ -1,9 +1,13 @@
-import { MOCK_PRODUCTS, safeSerialize } from '../../demo/database';
+import { MOCK_PRODUCTS, mockCompositeAtOutlet, mockHiddenProductIds, safeSerialize } from '../../demo/database';
 import { resolveUnit } from '@final-commerce/common';
 export const mockGetProducts = async (params) => {
     console.log('[Mock] getProducts called', params);
-    // Simple filter simulation
-    let products = MOCK_PRODUCTS;
+    // Simple filter simulation. Like the host: a product hidden at this outlet is left out, and a composite offers only
+    // what is sold here.
+    const hidden = mockHiddenProductIds();
+    let products = MOCK_PRODUCTS.filter((p) => !hidden.has(p._id)).map((p) => 
+    // B43: the host never hands a composite modifiers of its own.
+    p.composite ? { ...p, modifiers: [], composite: mockCompositeAtOutlet(p.composite, hidden) } : p);
     const query = params?.query || {};
     // Same rule as the real host: a bookable service is not catalogue stock and is left out unless
     // the query names `productType`. Mirrored here on purpose — a mock that hands back services the

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

@@ -27,7 +27,7 @@ export interface GetProductsParams {
         };
         status?: string;
         /**
-         * `simple` | `variable` | `booking`. Naming it at all switches OFF the default exclusion
+         * `simple` | `variable` | `booking` | `composite`. Naming it at all switches OFF the default exclusion
          * of bookable services — including `{ $ne: 'booking' }`, which then means what it says.
          */
         productType?: string | {

package/dist/actions/set-product-modifier-selections/mock.js

@@ -30,6 +30,18 @@ export const mockSetProductModifierSelections = async (params) => {
             timestamp: new Date().toISOString(),
         };
     }
+    // Like the host (FT-83): a composite line's modifiers belong to its components.
+    if (line.components?.length) {
+        return {
+            success: false,
+            reason: 'The modifiers of a composite line cannot be edited yet: remove the line and add it again with its picks',
+            internalId: line.internalId,
+            selections: [],
+            rows: [],
+            modifiersTotal: 0,
+            timestamp: new Date().toISOString(),
+        };
+    }
     // Full replacement — passing [] clears the rows. The line drops the product's resolved
     // stack when it is built, so the menu is re-read from the catalogue to price against.
     // Cart totals are not touched, for the same reason addProductToCart does not move them

package/dist/actions/set-variant-unavailable/action.d.ts

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

package/dist/actions/set-variant-unavailable/action.js

@@ -0,0 +1,4 @@
+import { commandFrameClient } from '../../client';
+export const setVariantUnavailable = async (params) => {
+    return await commandFrameClient.call('setVariantUnavailable', params);
+};

package/dist/actions/set-variant-unavailable/mock.d.ts

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

package/dist/actions/set-variant-unavailable/mock.js

@@ -0,0 +1,12 @@
+import { MOCK_OUTLET, MOCK_PRODUCTS } from '../../demo/database';
+export const mockSetVariantUnavailable = async (params) => {
+    console.log('[Mock] setVariantUnavailable called', params);
+    if (!params?.variantId)
+        throw new Error('variantId is required');
+    const { variantId, unavailable } = params;
+    const variant = MOCK_PRODUCTS.flatMap((product) => product.variants).find((v) => v._id === variantId);
+    if (!variant)
+        throw new Error(`Variant with ID ${variantId} not found`);
+    variant.unavailable = unavailable;
+    return { success: true, variantId, outletId: MOCK_OUTLET.id, unavailable, timestamp: new Date().toISOString() };
+};

package/dist/actions/set-variant-unavailable/types.d.ts

@@ -0,0 +1,17 @@
+export interface SetVariantUnavailableParams {
+    /** Variant to mark or unmark. */
+    variantId: string;
+    /**
+     * `true` marks the variant "can't be sold here right now" at the ACTIVE outlet; `false` removes the mark.
+     * Independent of stock and of catalog visibility. Needs a connection: the host refuses offline.
+     */
+    unavailable: boolean;
+}
+export interface SetVariantUnavailableResponse {
+    success: boolean;
+    variantId: string;
+    outletId: string;
+    unavailable: boolean;
+    timestamp: string;
+}
+export type SetVariantUnavailable = (params?: SetVariantUnavailableParams) => Promise<SetVariantUnavailableResponse>;

package/dist/actions/set-variant-unavailable/types.js

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

package/dist/demo/database.d.ts

@@ -2,7 +2,7 @@
  * Mock Database for Standalone/Demo Mode
  * Stores mock data that mimics the Render environment
  */
-import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFActiveCart, CFCategory, CFActiveProduct, CFSession, CFActiveRefundDetails, CFSmartGridLayout, CFBooking, CFBookingAvailability, CFBookingResource, CFCartLineModifier, CFProdModifierBreakdown, CFModifierSelection, CFResolvedModifier } from '../CommonTypes';
+import { CFActiveCompany, CFActiveUser, CFActiveStation, CFActiveOutlet, CFActiveOrder, CFCustomer, CFProduct, CFComposite, CFCartLineComponent, CFActiveCart, CFCategory, CFActiveProduct, CFSession, CFActiveRefundDetails, CFSmartGridLayout, CFBooking, CFBookingAvailability, CFBookingResource, CFBookingSlot, CFCartLineModifier, CFProdModifierBreakdown, CFModifierSelection, CFResolvedModifier } from '../CommonTypes';
 export * from './mocks';
 /** Replace mock catalog / context data in place (same array references mock handlers use). */
 export interface MockDatabaseConfig {
@@ -19,6 +19,12 @@ export interface MockDatabaseConfig {
     bookingResources?: CFBookingResource[];
     /** Windows already taken when the dataset loads, so a calendar does not open empty. */
     bookings?: CFBooking[];
+    /** Products hidden at an outlet (the host's `catalog-visibility`, product-level rows). Empty = sold everywhere. */
+    catalogVisibility?: MockCatalogVisibility[];
+}
+export interface MockCatalogVisibility {
+    productId: string;
+    outletId: string;
 }
 export declare const MOCK_COMPANY: CFActiveCompany;
 export declare const MOCK_OUTLET_MAIN: CFActiveOutlet;
@@ -38,20 +44,20 @@ export declare const MOCK_CATEGORY_SPECIALTY: CFCategory;
 export declare const MOCK_CATEGORY_BASIC: CFCategory;
 export declare const MOCK_CATEGORY_VEGAN: CFCategory;
 export declare const MOCK_CATEGORY_SPICY: CFCategory;
-export declare const MOCK_PRODUCT_BASIL_ALMOND: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_BEER: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_BEET: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_CARAMELIZED: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_GARLIC_ONION: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_GARLIC: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_GINGER_LIME: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_LEMON: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_RED_PEPPER: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_ROASTED_TOMATO: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_MINT_LEMON: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_CHILI_GARLIC: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_HABANERO: import("@final-commerce/common/pos-types").FullProduct;
-export declare const MOCK_PRODUCT_BLACK_GARLIC: import("@final-commerce/common/pos-types").FullProduct;
+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_PRODUCT_MINT_LEMON: CFProduct;
+export declare const MOCK_PRODUCT_CHILI_GARLIC: CFProduct;
+export declare const MOCK_PRODUCT_HABANERO: CFProduct;
+export declare const MOCK_PRODUCT_BLACK_GARLIC: CFProduct;
 export declare const MOCK_ORDER_1: CFActiveOrder;
 export declare const MOCK_ORDER_2: CFActiveOrder;
 export declare const MOCK_ORDER_3: CFActiveOrder;
@@ -64,8 +70,40 @@ export declare const MOCK_OUTLETS: import("@final-commerce/common/pos-types").Ac
 export declare const MOCK_CUSTOMERS: import("@final-commerce/common/pos-types").ActiveCustomer[];
 export declare const MOCK_CATEGORIES: import("@final-commerce/common/pos-types").Category[];
 export declare const MOCK_PRODUCT_HAIRCUT: CFProduct;
-export declare const MOCK_PRODUCTS: import("@final-commerce/common/pos-types").FullProduct[];
+export declare const MOCK_PRODUCT_PASTE_TRIO: CFProduct;
+export declare const MOCK_PRODUCTS: CFProduct[];
 export declare const MOCK_ORDERS: import("@final-commerce/common/pos-types").ActiveOrder[];
+/** Nothing hidden by default; `setMockDatabase({ catalogVisibility })` hides products at an outlet. */
+export declare const MOCK_CATALOG_VISIBILITY: MockCatalogVisibility[];
+/**
+ * The host's cart stock check for composites (kaching `compositeStockRefusal`), over the demo shelves — a copy: what the
+ * cart takes of each component's variant (plain lines and components × their line quantity) against its shelf here.
+ * The demo has no pools or units, so it counts per variant; untracked and backordered variants are never short.
+ */
+export declare function mockCompositeStockRefusal(products: {
+    variantId: string;
+    quantity: number;
+    components?: CFCartLineComponent[];
+}[]): string | null;
+/** Product ids hidden at the demo's active outlet. */
+export declare const mockHiddenProductIds: () => Set<string>;
+/**
+ * The host's outlet rules for a composite (kaching `resolveComposite`), over the demo's static view — a copy, change both
+ * in one step: an item whose product is hidden here is left out, a category item keeps only products sold here (none →
+ * `'empty'`), an Optional part with nothing to pick is not offered, a required one with nothing makes it unavailable,
+ * and the D36 default and "from" price are read off what is left.
+ */
+/** B41: the seats a bookable demo product has free in the slot starting at `startAt` — as the host reads them. */
+export declare function mockBookableWindow(productId: string, startAt: string): {
+    free: number;
+    slot: CFBookingSlot | null;
+};
+export declare const mockIsBookable: (productId: string) => boolean;
+export declare function mockCompositeAtOutlet(composite: Omit<CFComposite, 'needsDate'>, hidden?: Set<string>, 
+/** B41: the window bookable items are judged in; absent = `by_date`. */
+slot?: {
+    startAt: string;
+}): CFComposite;
 export declare const MOCK_PARKED_ORDERS: CFActiveOrder[];
 export declare let MOCK_USER: CFActiveUser;
 export declare let MOCK_STATION: CFActiveStation;