@feedmepos/order-plugin-gallery 0.0.10-beta.0 → 0.0.10-beta.2

package/dist/plugins/compulsory-items.js

@@ -1,46 +1,5 @@
-const formatQty = (qty) => {
-    if (Number.isInteger(qty))
-        return `${qty}`;
-    return qty.toFixed(2).replace(/\.?0+$/, "");
-};
-const addQuantity = (quantityMap, itemId, quantity) => {
-    if (!itemId || typeof itemId !== "string")
-        return;
-    if (typeof quantity !== "number" || !Number.isFinite(quantity))
-        return;
-    if (quantity <= 0)
-        return;
-    quantityMap.set(itemId, (quantityMap.get(itemId) || 0) + quantity);
-};
-const getQuantityMap = (items) => {
-    const quantityMap = new Map();
-    for (const item of items) {
-        addQuantity(quantityMap, item.productId, item.quantity);
-    }
-    return quantityMap;
-};
-const getNormalizedRules = (rawRules) => {
-    if (!Array.isArray(rawRules))
-        return [];
-    const normalizedRules = [];
-    for (const rule of rawRules) {
-        const itemId = typeof rule?.itemId === "string"
-            ? rule.itemId.trim()
-            : "";
-        const minQty = rule?.minQty;
-        const maxQty = rule?.maxQty;
-        if (!itemId || !Number.isFinite(minQty) || !Number.isFinite(maxQty)) {
-            console.warn("[compulsory-items] Skip invalid rule. Expect { itemId, minQty, maxQty } with finite numbers.", rule);
-            continue;
-        }
-        if (minQty < 0 || maxQty < minQty) {
-            console.warn("[compulsory-items] Skip invalid rule. Expect minQty >= 0 and maxQty >= minQty.", rule);
-            continue;
-        }
-        normalizedRules.push({ itemId, minQty, maxQty });
-    }
-    return normalizedRules;
-};
+import { OrderItemUtil, } from "@feedmepos/ordering-sdk";
+import { getAutoAddPlans, getNormalizedRules, getRuleQuantitySummary as getRuleQuantitySummaryShared, getViolationMessages, } from "./compulsory-items.shared.js";
 const getItemTitleMap = (sdk) => {
     const titleMap = new Map();
     const menuItems = (sdk.menuManager.state.value.menu?.items ||
@@ -63,39 +22,96 @@ const getItemTitleMap = (sdk) => {
     }
     return titleMap;
 };
-const compulsoryItemsPlugin = ({ sdk, onBeforeSubmitOrder, pluginParams, }) => {
-    onBeforeSubmitOrder(() => {
+const getRuleQuantitySummary = (sdk, rules, slotActiveBills, draftItems) => {
+    const itemTitleMap = getItemTitleMap(sdk);
+    return getRuleQuantitySummaryShared({
+        rules,
+        slotActiveBills,
+        draftItems,
+        itemTitleMap,
+    });
+};
+const getMenuItemByIdMap = (sdk) => {
+    const menuItems = (sdk.menuManager.state.value.menu?.items ||
+        []);
+    return new Map(menuItems.map((item) => [item.id, item]));
+};
+const isMenuItemAutoAddable = (menuItem) => {
+    return (menuItem.groups?.length || 0) === 0;
+};
+const buildDefaultOrderItem = (sdk, menuItem, quantity) => {
+    const order = sdk.orderManager.state.value.order;
+    const option = sdk.orderManager.state.value.option;
+    if (!order || !option)
+        return null;
+    const baseState = {
+        variantSelected: null,
+        subItems: [],
+        isTakeaway: Boolean(sdk.orderManager.state.value.isPickupTakeawayOrdering &&
+            menuItem.takeawayUsed),
+        takeawaySelected: sdk.orderManager.state.value.isPickupTakeawayOrdering &&
+            menuItem.takeawayUsed
+            ? menuItem.takeawayUsed
+            : null,
+        remark: "",
+        quantity,
+    };
+    return OrderItemUtil.buildOrderItem(baseState, menuItem, option.type);
+};
+const autoAddCompulsoryItems = async (sdk, rules, slotActiveBills) => {
+    const order = sdk.orderManager.state.value.order;
+    if (!order)
+        return;
+    const draftItems = (order.draft || []);
+    const { submittedQtyByItemId, draftQtyByItemId, itemTitleMap } = getRuleQuantitySummary(sdk, rules, slotActiveBills, draftItems);
+    const menuItemById = getMenuItemByIdMap(sdk);
+    const itemsToAdd = [];
+    const addPlans = getAutoAddPlans(rules, {
+        submittedQtyByItemId,
+        draftQtyByItemId,
+        itemTitleMap,
+    });
+    for (const plan of addPlans) {
+        const menuItem = menuItemById.get(plan.itemId);
+        const itemTitle = itemTitleMap.get(plan.itemId) || plan.itemId;
+        if (!menuItem) {
+            console.warn(`[compulsory-items] Skip auto add for "${itemTitle}". Menu item not found in current menu.`);
+            continue;
+        }
+        if (!isMenuItemAutoAddable(menuItem)) {
+            console.warn(`[compulsory-items] Skip auto add for "${itemTitle}". Only simple items without variants/addons are supported.`);
+            continue;
+        }
+        const orderItem = buildDefaultOrderItem(sdk, menuItem, plan.missingQty);
+        if (!orderItem) {
+            console.warn(`[compulsory-items] Skip auto add for "${itemTitle}". Failed to build a default cart item.`);
+            continue;
+        }
+        itemsToAdd.push(orderItem);
+    }
+    if (itemsToAdd.length > 0) {
+        await sdk.orderManager.updateItems(itemsToAdd);
+    }
+};
+const compulsoryItemsPlugin = ({ sdk, onOrderSessionReady, onBeforeSubmitOrder, pluginParams, }) => {
+    const getRules = () => {
         const params = (pluginParams || {});
-        const rules = getNormalizedRules(params.itemLimitConfig);
+        return getNormalizedRules(params.itemLimitConfig);
+    };
+    onOrderSessionReady(async (params) => {
+        if (params.isPreviewMode)
+            return;
+        const rules = getRules();
+        if (rules.length === 0)
+            return;
+        await autoAddCompulsoryItems(sdk, rules, params.slotActiveBills);
+    });
+    onBeforeSubmitOrder(() => {
+        const rules = getRules();
         if (rules.length === 0)
             return true;
-        const submittedItems = (sdk.orderManager.state.value.slotActiveBills?.[0]?.items ||
-            []);
-        const draftItems = (sdk.orderManager.state.value.order?.draft || []);
-        const submittedQtyByItemId = getQuantityMap(submittedItems);
-        const draftQtyByItemId = getQuantityMap(draftItems);
-        const itemTitleMap = getItemTitleMap(sdk);
-        const violationMessages = [];
-        for (const rule of rules) {
-            const submittedQty = submittedQtyByItemId.get(rule.itemId) || 0;
-            const draftQty = draftQtyByItemId.get(rule.itemId) || 0;
-            const totalQty = submittedQty + draftQty;
-            const itemTitle = itemTitleMap.get(rule.itemId) || rule.itemId;
-            if (totalQty < rule.minQty) {
-                const delta = rule.minQty - totalQty;
-                violationMessages.push(`Add ${formatQty(delta)} more "${itemTitle}" (minimum ${formatQty(rule.minQty)}, current total ${formatQty(totalQty)}).`);
-            }
-            if (submittedQty > rule.maxQty) {
-                if (draftQty > 0) {
-                    violationMessages.push(`"${itemTitle}" is already above the limit in submitted orders. Remove ${formatQty(draftQty)} from your current cart to continue.`);
-                }
-                continue;
-            }
-            if (totalQty > rule.maxQty) {
-                const delta = totalQty - rule.maxQty;
-                violationMessages.push(`Remove ${formatQty(delta)} "${itemTitle}" from your current cart (maximum ${formatQty(rule.maxQty)}, current total ${formatQty(totalQty)}).`);
-            }
-        }
+        const quantitySummary = getRuleQuantitySummary(sdk, rules, sdk.orderManager.state.value.slotActiveBills || [], (sdk.orderManager.state.value.order?.draft || []));
+        const violationMessages = getViolationMessages(rules, quantitySummary);
         if (violationMessages.length === 0) {
             return true;
         }

package/dist/plugins/compulsory-items.shared.d.ts

@@ -0,0 +1,35 @@
+import type { CCdtoBillSummary } from "@feedmepos/ordering-sdk";
+export type CompulsoryItemRule = {
+    itemId: string;
+    minQty: number;
+    maxQty: number;
+};
+export type CompulsoryItemsPluginParams = {
+    itemLimitConfig: CompulsoryItemRule[];
+};
+export type QuantityItem = {
+    productId?: string | null;
+    name?: string | null;
+    title?: string | null;
+    quantity?: number | null;
+    status?: string | null;
+};
+export type RuleQuantitySummary = {
+    submittedQtyByItemId: Map<string, number>;
+    draftQtyByItemId: Map<string, number>;
+    itemTitleMap: Map<string, string>;
+};
+export declare const formatQty: (qty: number) => string;
+export declare const getNormalizedRules: (rawRules: unknown) => CompulsoryItemRule[];
+export declare const getFallbackRuleItemIdByNameMap: (rules: CompulsoryItemRule[], itemTitleMap: Map<string, string>) => Map<string, string>;
+export declare const getRuleQuantitySummary: (params: {
+    rules: CompulsoryItemRule[];
+    slotActiveBills: CCdtoBillSummary[];
+    draftItems: QuantityItem[];
+    itemTitleMap: Map<string, string>;
+}) => RuleQuantitySummary;
+export declare const getAutoAddPlans: (rules: CompulsoryItemRule[], quantitySummary: RuleQuantitySummary) => Array<{
+    itemId: string;
+    missingQty: number;
+}>;
+export declare const getViolationMessages: (rules: CompulsoryItemRule[], quantitySummary: RuleQuantitySummary) => string[];

package/dist/plugins/compulsory-items.shared.js

@@ -0,0 +1,131 @@
+const INCLUDED_BILL_ITEM_STATUSES = new Set(["SENT", "DRAFT"]);
+export const formatQty = (qty) => {
+    if (Number.isInteger(qty))
+        return `${qty}`;
+    return qty.toFixed(2).replace(/\.?0+$/, "");
+};
+const normalizeLookupKey = (value) => {
+    if (typeof value !== "string")
+        return null;
+    const normalizedValue = value.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalizedValue || null;
+};
+const addQuantity = (quantityMap, itemId, quantity) => {
+    if (!itemId || typeof itemId !== "string")
+        return;
+    if (typeof quantity !== "number" || !Number.isFinite(quantity))
+        return;
+    if (quantity <= 0)
+        return;
+    quantityMap.set(itemId, (quantityMap.get(itemId) || 0) + quantity);
+};
+const getResolvedItemId = (item, fallbackItemIdByName) => {
+    const productId = typeof item.productId === "string" ? item.productId.trim() : "";
+    if (productId)
+        return productId;
+    if (!fallbackItemIdByName)
+        return null;
+    const itemName = normalizeLookupKey(item.name || item.title);
+    if (!itemName)
+        return null;
+    return fallbackItemIdByName.get(itemName) || null;
+};
+const getQuantityMap = (items, fallbackItemIdByName) => {
+    const quantityMap = new Map();
+    for (const item of items) {
+        addQuantity(quantityMap, getResolvedItemId(item, fallbackItemIdByName), item.quantity);
+    }
+    return quantityMap;
+};
+export const getNormalizedRules = (rawRules) => {
+    if (!Array.isArray(rawRules))
+        return [];
+    const normalizedRules = [];
+    for (const rule of rawRules) {
+        const itemId = typeof rule?.itemId === "string"
+            ? rule.itemId.trim()
+            : "";
+        const minQty = rule?.minQty;
+        const maxQty = rule?.maxQty;
+        if (!itemId || !Number.isFinite(minQty) || !Number.isFinite(maxQty)) {
+            console.warn("[compulsory-items] Skip invalid rule. Expect { itemId, minQty, maxQty } with finite numbers.", rule);
+            continue;
+        }
+        if (minQty < 0 || maxQty < minQty) {
+            console.warn("[compulsory-items] Skip invalid rule. Expect minQty >= 0 and maxQty >= minQty.", rule);
+            continue;
+        }
+        normalizedRules.push({ itemId, minQty, maxQty });
+    }
+    return normalizedRules;
+};
+export const getFallbackRuleItemIdByNameMap = (rules, itemTitleMap) => {
+    const fallbackItemIdByName = new Map();
+    const ambiguousNames = new Set();
+    for (const rule of rules) {
+        const itemTitle = itemTitleMap.get(rule.itemId);
+        const normalizedTitle = normalizeLookupKey(itemTitle);
+        if (!normalizedTitle || ambiguousNames.has(normalizedTitle))
+            continue;
+        const existingItemId = fallbackItemIdByName.get(normalizedTitle);
+        if (!existingItemId) {
+            fallbackItemIdByName.set(normalizedTitle, rule.itemId);
+            continue;
+        }
+        if (existingItemId !== rule.itemId) {
+            fallbackItemIdByName.delete(normalizedTitle);
+            ambiguousNames.add(normalizedTitle);
+        }
+    }
+    return fallbackItemIdByName;
+};
+const getSubmittedItems = (slotActiveBills) => slotActiveBills.flatMap((bill) => (bill.items || []).filter((item) => INCLUDED_BILL_ITEM_STATUSES.has(String(item.status || ""))));
+export const getRuleQuantitySummary = (params) => {
+    const fallbackRuleItemIdByName = getFallbackRuleItemIdByNameMap(params.rules, params.itemTitleMap);
+    return {
+        itemTitleMap: params.itemTitleMap,
+        submittedQtyByItemId: getQuantityMap(getSubmittedItems(params.slotActiveBills), fallbackRuleItemIdByName),
+        draftQtyByItemId: getQuantityMap(params.draftItems),
+    };
+};
+export const getAutoAddPlans = (rules, quantitySummary) => {
+    const plans = [];
+    for (const rule of rules) {
+        const submittedQty = quantitySummary.submittedQtyByItemId.get(rule.itemId) || 0;
+        if (submittedQty >= rule.minQty)
+            continue;
+        const draftQty = quantitySummary.draftQtyByItemId.get(rule.itemId) || 0;
+        const missingQty = Math.max(0, rule.minQty - submittedQty - draftQty);
+        if (missingQty <= 0)
+            continue;
+        plans.push({
+            itemId: rule.itemId,
+            missingQty,
+        });
+    }
+    return plans;
+};
+export const getViolationMessages = (rules, quantitySummary) => {
+    const violationMessages = [];
+    for (const rule of rules) {
+        const submittedQty = quantitySummary.submittedQtyByItemId.get(rule.itemId) || 0;
+        const draftQty = quantitySummary.draftQtyByItemId.get(rule.itemId) || 0;
+        const totalQty = submittedQty + draftQty;
+        const itemTitle = quantitySummary.itemTitleMap.get(rule.itemId) || rule.itemId;
+        if (totalQty < rule.minQty) {
+            const delta = rule.minQty - totalQty;
+            violationMessages.push(`Add ${formatQty(delta)} more "${itemTitle}" (minimum ${formatQty(rule.minQty)}, current total ${formatQty(totalQty)}).`);
+        }
+        if (submittedQty > rule.maxQty) {
+            if (draftQty > 0) {
+                violationMessages.push(`"${itemTitle}" is already above the limit in submitted orders. Remove ${formatQty(draftQty)} from your current cart to continue.`);
+            }
+            continue;
+        }
+        if (totalQty > rule.maxQty) {
+            const delta = totalQty - rule.maxQty;
+            violationMessages.push(`Remove ${formatQty(delta)} "${itemTitle}" from your current cart (maximum ${formatQty(rule.maxQty)}, current total ${formatQty(totalQty)}).`);
+        }
+    }
+    return violationMessages;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feedmepos/order-plugin-gallery",
-  "version": "0.0.10-beta.0",
+  "version": "0.0.10-beta.2",
   "type": "module",
   "files": [
     "dist"