@fayz-ai/plugin-orders 0.2.0

package/dist/index.js

@@ -0,0 +1,1178 @@
+import { getNextStatus, STATUS_FLOW } from './chunk-7LFVFZKZ.js';
+import React from 'react';
+import { createStore } from 'zustand/vanilla';
+import { PluginSettingsPanel, dedup } from '@fayz-ai/saas';
+import { toast } from 'sonner';
+import { createFayzClient } from '@fayz-ai/sdk';
+
+// src/data/mock.ts
+var uid = 100;
+function nextId(prefix) {
+  return prefix + "-" + ++uid;
+}
+var now = (/* @__PURE__ */ new Date()).toISOString();
+function makeItem(orderId, name, quantity, unitPrice, sortOrder, productId) {
+  const id = nextId("item");
+  return {
+    id,
+    orderId,
+    productId,
+    name,
+    quantity,
+    unitPrice,
+    discount: 0,
+    total: quantity * unitPrice,
+    sortOrder,
+    createdAt: now
+  };
+}
+function createSeedOrders() {
+  const order1Id = nextId("order");
+  const order1Items = [
+    makeItem(order1Id, "Classic Burger", 1, 32, 0, "prod-burger-classic"),
+    makeItem(order1Id, "Fries", 1, 15, 1, "prod-fries")
+  ];
+  const order1 = {
+    id: order1Id,
+    referenceNumber: "ORD-0001",
+    kind: "dine_in",
+    status: "preparing",
+    source: "pos",
+    tableId: "table-3",
+    tableName: "Table 3",
+    subtotal: 47,
+    discount: 0,
+    tax: 0,
+    total: 47,
+    currency: "BRL",
+    tags: [],
+    items: order1Items,
+    tenantId: "tenant-mock",
+    createdAt: now,
+    updatedAt: now
+  };
+  const order2Id = nextId("order");
+  const order2Items = [
+    makeItem(order2Id, "Cheese Burger", 1, 36, 0, "prod-burger-cheese")
+  ];
+  const order2 = {
+    id: order2Id,
+    referenceNumber: "ORD-0002",
+    kind: "takeout",
+    status: "ready",
+    source: "pos",
+    subtotal: 36,
+    discount: 0,
+    tax: 0,
+    total: 36,
+    currency: "BRL",
+    tags: [],
+    items: order2Items,
+    tenantId: "tenant-mock",
+    createdAt: now,
+    updatedAt: now
+  };
+  const order3Id = nextId("order");
+  const order3Items = [
+    makeItem(order3Id, "Margherita Pizza", 1, 38, 0, "prod-pizza-margherita"),
+    makeItem(order3Id, "Caesar Salad", 1, 22, 1, "prod-salad-caesar"),
+    makeItem(order3Id, "Soda 350ml", 1, 12, 2, "prod-soda")
+  ];
+  const order3 = {
+    id: order3Id,
+    referenceNumber: "ORD-0003",
+    kind: "delivery",
+    status: "confirmed",
+    source: "ifood",
+    subtotal: 72,
+    discount: 0,
+    tax: 0,
+    total: 72,
+    currency: "BRL",
+    tags: [],
+    items: order3Items,
+    tenantId: "tenant-mock",
+    createdAt: now,
+    updatedAt: now
+  };
+  const order4Id = nextId("order");
+  const order4Items = [
+    makeItem(order4Id, "BBQ Bacon Burger", 1, 42, 0, "prod-burger-bbq")
+  ];
+  const order4 = {
+    id: order4Id,
+    referenceNumber: "ORD-0004",
+    kind: "dine_in",
+    status: "new",
+    source: "pos",
+    tableId: "table-7",
+    tableName: "Table 7",
+    subtotal: 42,
+    discount: 0,
+    tax: 0,
+    total: 42,
+    currency: "BRL",
+    tags: [],
+    items: order4Items,
+    tenantId: "tenant-mock",
+    createdAt: now,
+    updatedAt: now
+  };
+  const order5Id = nextId("order");
+  const order5Items = [
+    makeItem(order5Id, "Classic Burger", 2, 32, 0, "prod-burger-classic"),
+    makeItem(order5Id, "Fries", 1, 15, 1, "prod-fries"),
+    makeItem(order5Id, "Onion Rings", 1, 18, 2, "prod-onion-rings"),
+    makeItem(order5Id, "Milkshake", 1, 23, 3, "prod-milkshake")
+  ];
+  const order5 = {
+    id: order5Id,
+    referenceNumber: "ORD-0005",
+    kind: "dine_in",
+    status: "completed",
+    source: "pos",
+    tableId: "table-1",
+    tableName: "Table 1",
+    subtotal: 120,
+    discount: 0,
+    tax: 0,
+    total: 120,
+    currency: "BRL",
+    tags: [],
+    items: order5Items,
+    tenantId: "tenant-mock",
+    createdAt: now,
+    updatedAt: now,
+    completedAt: now
+  };
+  return [order1, order2, order3, order4, order5];
+}
+function recomputeTotals(order) {
+  order.subtotal = order.items.reduce((sum, i) => sum + i.total, 0);
+  order.total = order.subtotal - order.discount + order.tax;
+}
+var refCounter = 5;
+function generateReferenceNumber() {
+  refCounter++;
+  return "ORD-" + String(refCounter).padStart(4, "0");
+}
+function toDateStr(d) {
+  return d.toISOString().slice(0, 10);
+}
+function createMockOrdersProvider() {
+  const orders = createSeedOrders();
+  function findOrder(id) {
+    return orders.find((o) => o.id === id);
+  }
+  function findItem(itemId) {
+    for (const order of orders) {
+      const index = order.items.findIndex((i) => i.id === itemId);
+      if (index !== -1) return { order, item: order.items[index], index };
+    }
+    return void 0;
+  }
+  const provider = {
+    // ------------------------------------------------------------------
+    // getOrders
+    // ------------------------------------------------------------------
+    async getOrders(query) {
+      let result = [...orders];
+      if (query.kind) {
+        const kinds = Array.isArray(query.kind) ? query.kind : [query.kind];
+        result = result.filter((o) => kinds.includes(o.kind));
+      }
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status];
+        result = result.filter((o) => statuses.includes(o.status));
+      }
+      if (query.source) {
+        result = result.filter((o) => o.source === query.source);
+      }
+      if (query.tableId) {
+        result = result.filter((o) => o.tableId === query.tableId);
+      }
+      if (query.assigneeId) {
+        result = result.filter((o) => o.assigneeId === query.assigneeId);
+      }
+      if (query.search) {
+        const q = query.search.toLowerCase();
+        result = result.filter(
+          (o) => o.referenceNumber.toLowerCase().includes(q) || o.partyName?.toLowerCase().includes(q) || o.tableName?.toLowerCase().includes(q) || o.items.some((i) => i.name.toLowerCase().includes(q))
+        );
+      }
+      if (query.dateRange) {
+        const from = query.dateRange.from;
+        const to = query.dateRange.to;
+        result = result.filter((o) => {
+          const d = o.createdAt.slice(0, 10);
+          return d >= from && d <= to;
+        });
+      }
+      result.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+      const total = result.length;
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 20;
+      const start = (page - 1) * pageSize;
+      const data = result.slice(start, start + pageSize);
+      return { data, total };
+    },
+    // ------------------------------------------------------------------
+    // getOrderById
+    // ------------------------------------------------------------------
+    async getOrderById(id) {
+      return findOrder(id) ?? null;
+    },
+    // ------------------------------------------------------------------
+    // createOrder
+    // ------------------------------------------------------------------
+    async createOrder(input) {
+      const orderId = nextId("order");
+      const items = input.items.map((item, idx) => ({
+        id: nextId("item"),
+        orderId,
+        productId: item.productId,
+        name: item.name,
+        quantity: item.quantity,
+        unitPrice: item.unitPrice,
+        discount: item.discount ?? 0,
+        total: item.quantity * item.unitPrice - (item.discount ?? 0),
+        sortOrder: idx,
+        modifiers: item.modifiers,
+        kitchenNotes: item.kitchenNotes,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      const subtotal = items.reduce((sum, i) => sum + i.total, 0);
+      const order = {
+        id: orderId,
+        referenceNumber: generateReferenceNumber(),
+        kind: input.kind,
+        status: "new",
+        source: input.source ?? "pos",
+        tableId: input.tableId,
+        partyId: input.partyId,
+        assigneeId: input.assigneeId,
+        notes: input.notes,
+        estimatedMinutes: input.estimatedMinutes,
+        subtotal,
+        discount: 0,
+        tax: 0,
+        total: subtotal,
+        currency: "BRL",
+        tags: [],
+        items,
+        tenantId: "tenant-mock",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      orders.push(order);
+      return order;
+    },
+    // ------------------------------------------------------------------
+    // updateOrderStatus
+    // ------------------------------------------------------------------
+    async updateOrderStatus(input) {
+      const order = findOrder(input.orderId);
+      if (!order) throw new Error(`Order not found: ${input.orderId}`);
+      if (input.status !== "cancelled") {
+        const flow = STATUS_FLOW[order.kind];
+        const currentIdx = flow.indexOf(order.status);
+        const targetIdx = flow.indexOf(input.status);
+        if (targetIdx < 0 || targetIdx !== currentIdx + 1) {
+          const next = getNextStatus(order.kind, order.status);
+          throw new Error(
+            `Invalid status transition: ${order.status} \u2192 ${input.status}. ` + (next ? `Expected next status: ${next}` : "Order is already in a terminal state.")
+          );
+        }
+      }
+      order.status = input.status;
+      order.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (input.status === "completed") {
+        order.completedAt = order.updatedAt;
+      }
+      return order;
+    },
+    // ------------------------------------------------------------------
+    // updateOrder
+    // ------------------------------------------------------------------
+    async updateOrder(id, data) {
+      const order = findOrder(id);
+      if (!order) throw new Error(`Order not found: ${id}`);
+      const { id: _id, items: _items, tenantId: _t, createdAt: _c, ...safe } = data;
+      Object.assign(order, safe);
+      order.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return order;
+    },
+    // ------------------------------------------------------------------
+    // cancelOrder
+    // ------------------------------------------------------------------
+    async cancelOrder(id, reason) {
+      const order = findOrder(id);
+      if (!order) throw new Error(`Order not found: ${id}`);
+      order.status = "cancelled";
+      order.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (reason) {
+        order.notes = order.notes ? `${order.notes}
+Cancelled: ${reason}` : `Cancelled: ${reason}`;
+      }
+    },
+    // ------------------------------------------------------------------
+    // addOrderItem
+    // ------------------------------------------------------------------
+    async addOrderItem(orderId, item) {
+      const order = findOrder(orderId);
+      if (!order) throw new Error(`Order not found: ${orderId}`);
+      const newItem = {
+        id: nextId("item"),
+        orderId,
+        productId: item.productId,
+        name: item.name,
+        quantity: item.quantity,
+        unitPrice: item.unitPrice,
+        discount: item.discount ?? 0,
+        total: item.quantity * item.unitPrice - (item.discount ?? 0),
+        sortOrder: order.items.length,
+        modifiers: item.modifiers,
+        kitchenNotes: item.kitchenNotes,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      order.items.push(newItem);
+      recomputeTotals(order);
+      order.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return newItem;
+    },
+    // ------------------------------------------------------------------
+    // removeOrderItem
+    // ------------------------------------------------------------------
+    async removeOrderItem(itemId) {
+      const found = findItem(itemId);
+      if (!found) throw new Error(`Order item not found: ${itemId}`);
+      found.order.items.splice(found.index, 1);
+      recomputeTotals(found.order);
+      found.order.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    },
+    // ------------------------------------------------------------------
+    // updateOrderItem
+    // ------------------------------------------------------------------
+    async updateOrderItem(itemId, data) {
+      const found = findItem(itemId);
+      if (!found) throw new Error(`Order item not found: ${itemId}`);
+      const { id: _id, orderId: _oid, createdAt: _c, ...safe } = data;
+      Object.assign(found.item, safe);
+      found.item.total = found.item.quantity * found.item.unitPrice - found.item.discount;
+      recomputeTotals(found.order);
+      found.order.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return found.item;
+    },
+    // ------------------------------------------------------------------
+    // getSummary
+    // ------------------------------------------------------------------
+    async getSummary(dateRange) {
+      const today = toDateStr(/* @__PURE__ */ new Date());
+      const from = dateRange?.from ?? today;
+      const to = dateRange?.to ?? today;
+      const inRange = orders.filter((o) => {
+        const d = o.createdAt.slice(0, 10);
+        return d >= from && d <= to;
+      });
+      const completed = inRange.filter((o) => o.status !== "cancelled");
+      const revenue = completed.reduce((sum, o) => sum + o.total, 0);
+      const activeStatuses = /* @__PURE__ */ new Set(["new", "confirmed", "preparing", "ready", "served", "dispatched"]);
+      const active = orders.filter((o) => activeStatuses.has(o.status));
+      const ordersByKind = { dine_in: 0, takeout: 0, delivery: 0 };
+      const ordersByStatus = {};
+      for (const o of inRange) {
+        ordersByKind[o.kind] = (ordersByKind[o.kind] || 0) + 1;
+        ordersByStatus[o.status] = (ordersByStatus[o.status] || 0) + 1;
+      }
+      const itemMap = /* @__PURE__ */ new Map();
+      for (const o of completed) {
+        for (const item of o.items) {
+          const existing = itemMap.get(item.name);
+          if (existing) {
+            existing.quantity += item.quantity;
+            existing.revenue += item.total;
+          } else {
+            itemMap.set(item.name, { name: item.name, quantity: item.quantity, revenue: item.total });
+          }
+        }
+      }
+      const topItems = Array.from(itemMap.values()).sort((a, b) => b.quantity - a.quantity).slice(0, 5);
+      return {
+        todayOrderCount: inRange.length,
+        todayRevenue: revenue,
+        averageTicket: completed.length > 0 ? revenue / completed.length : 0,
+        activeOrderCount: active.length,
+        ordersByKind,
+        ordersByStatus,
+        topItems
+      };
+    }
+  };
+  return provider;
+}
+function createOrdersStore(provider) {
+  return createStore((set, get) => ({
+    orders: [],
+    ordersTotal: 0,
+    ordersLoading: false,
+    orderQuery: {},
+    activeOrders: [],
+    activeOrdersLoading: false,
+    summary: null,
+    summaryLoading: false,
+    selectedOrderId: null,
+    async fetchOrders(query) {
+      return dedup("orders:list:" + JSON.stringify(query), async () => {
+        set({ ordersLoading: true, orderQuery: query });
+        const result = await provider.getOrders(query);
+        set({ orders: result.data, ordersTotal: result.total, ordersLoading: false });
+      });
+    },
+    async fetchActiveOrders() {
+      return dedup("orders:active", async () => {
+        set({ activeOrdersLoading: true });
+        const result = await provider.getOrders({
+          status: ["new", "confirmed", "preparing", "ready"]
+        });
+        set({ activeOrders: result.data, activeOrdersLoading: false });
+      });
+    },
+    async fetchSummary(dateRange) {
+      return dedup("orders:summary", async () => {
+        set({ summaryLoading: true });
+        const summary = await provider.getSummary(dateRange);
+        set({ summary, summaryLoading: false });
+      });
+    },
+    selectOrder(id) {
+      set({ selectedOrderId: id });
+    },
+    async createOrder(input) {
+      try {
+        const order = await provider.createOrder(input);
+        const query = get().orderQuery;
+        const [result, summary] = await Promise.all([
+          provider.getOrders(query),
+          provider.getSummary()
+        ]);
+        set({ orders: result.data, ordersTotal: result.total, summary });
+        toast.success("Order created");
+        return order;
+      } catch (err) {
+        toast.error("Failed to create order", { description: err?.message });
+        throw err;
+      }
+    },
+    async advanceOrderStatus(orderId) {
+      try {
+        const { orders, activeOrders } = get();
+        const order = orders.find((o) => o.id === orderId) ?? activeOrders.find((o) => o.id === orderId);
+        if (!order) throw new Error("Order not found");
+        const nextStatus = getNextStatus(order.kind, order.status);
+        if (!nextStatus) throw new Error("No next status available");
+        await provider.updateOrderStatus({ orderId, status: nextStatus });
+        const activeResult = await provider.getOrders({
+          status: ["new", "confirmed", "preparing", "ready"]
+        });
+        set({ activeOrders: activeResult.data });
+        toast.success(`Order advanced to ${nextStatus.replace("_", " ")}`);
+      } catch (err) {
+        toast.error("Failed to advance order", { description: err?.message });
+        throw err;
+      }
+    },
+    async updateOrderStatus(input) {
+      try {
+        await provider.updateOrderStatus(input);
+        const query = get().orderQuery;
+        const [result, summary] = await Promise.all([
+          provider.getOrders(query),
+          provider.getSummary()
+        ]);
+        set({ orders: result.data, ordersTotal: result.total, summary });
+        toast.success("Order status updated");
+      } catch (err) {
+        toast.error("Failed to update status", { description: err?.message });
+        throw err;
+      }
+    },
+    async cancelOrder(id, reason) {
+      try {
+        await provider.cancelOrder(id, reason);
+        const query = get().orderQuery;
+        const [result, summary] = await Promise.all([
+          provider.getOrders(query),
+          provider.getSummary()
+        ]);
+        set({ orders: result.data, ordersTotal: result.total, summary });
+        toast.success("Order cancelled");
+      } catch (err) {
+        toast.error("Failed to cancel order", { description: err?.message });
+        throw err;
+      }
+    },
+    async addOrderItem(orderId, item) {
+      try {
+        await provider.addOrderItem(orderId, item);
+        const query = get().orderQuery;
+        const result = await provider.getOrders(query);
+        set({ orders: result.data, ordersTotal: result.total });
+        toast.success("Item added");
+      } catch (err) {
+        toast.error("Failed to add item", { description: err?.message });
+        throw err;
+      }
+    },
+    async removeOrderItem(itemId) {
+      try {
+        await provider.removeOrderItem(itemId);
+        const query = get().orderQuery;
+        const result = await provider.getOrders(query);
+        set({ orders: result.data, ordersTotal: result.total });
+        toast.success("Item removed");
+      } catch (err) {
+        toast.error("Failed to remove item", { description: err?.message });
+        throw err;
+      }
+    }
+  }));
+}
+
+// src/registries.ts
+var orderSourceEntity = {
+  name: "Order Source",
+  namePlural: "Order Sources",
+  icon: "Globe",
+  displayField: "name",
+  defaultSort: "name",
+  fields: [
+    { key: "name", label: "Name", type: "text", required: true, showInTable: true },
+    { key: "icon", label: "Icon", type: "text", showInTable: true },
+    { key: "isActive", label: "Active", type: "boolean", showInTable: true, defaultValue: true }
+  ],
+  data: { table: "order_sources", tenantScoped: true }
+};
+var ordersRegistries = [
+  {
+    id: "order-sources",
+    entity: orderSourceEntity,
+    icon: "Globe",
+    description: "Order sources and delivery platforms",
+    display: "table",
+    seedData: [
+      { id: "os-dine", name: "Dine-in", icon: "\u{1F37D}\uFE0F", isActive: true },
+      { id: "os-takeout", name: "Takeout", icon: "\u{1F961}", isActive: true },
+      { id: "os-ifood", name: "iFood", icon: "\u{1F534}", isActive: true },
+      { id: "os-99food", name: "99Food", icon: "\u{1F7E1}", isActive: true }
+    ]
+  }
+];
+
+// src/locales/en.ts
+var en = {
+  "orders.title": "Orders",
+  "orders.nav.kanban": "Orders",
+  "orders.nav.list": "History",
+  "orders.nav.new": "New Order",
+  "orders.nav.dashboard": "Dashboard",
+  "orders.kanban.title": "Orders",
+  "orders.kanban.subtitle": "Active orders",
+  "orders.kanban.noOrders": "No active orders",
+  "orders.kanban.noOrdersDesc": "Orders will appear here as they come in",
+  "orders.kanban.newOrder": "New Order",
+  "orders.kanban.advance": "Advance",
+  "orders.kanban.cancel": "Cancel Order",
+  "orders.kanban.column.new": "New",
+  "orders.kanban.column.confirmed": "Confirmed",
+  "orders.kanban.column.preparing": "Preparing",
+  "orders.kanban.column.ready": "Ready",
+  "orders.kanban.column.out": "Out",
+  "orders.kanban.column.completed": "Completed",
+  "orders.kanban.column.cancelled": "Cancelled",
+  "orders.detail.title": "Order Details",
+  "orders.detail.items": "Items",
+  "orders.detail.table": "Table",
+  "orders.detail.customer": "Customer",
+  "orders.detail.waiter": "Waiter",
+  "orders.detail.source": "Source",
+  "orders.detail.subtotal": "Subtotal",
+  "orders.detail.discount": "Discount",
+  "orders.detail.tax": "Tax",
+  "orders.detail.total": "Total",
+  "orders.detail.notes": "Notes",
+  "orders.newOrder.title": "New Order",
+  "orders.newOrder.selectKind": "Order type",
+  "orders.newOrder.dineIn": "Dine-in",
+  "orders.newOrder.takeout": "Takeout",
+  "orders.newOrder.delivery": "Delivery",
+  "orders.newOrder.selectTable": "Select table",
+  "orders.newOrder.addItems": "Add items",
+  "orders.newOrder.searchItems": "Search menu...",
+  "orders.newOrder.noItems": "No items added yet",
+  "orders.newOrder.confirm": "Place Order",
+  "orders.newOrder.cancel": "Cancel",
+  "orders.list.title": "Order History",
+  "orders.list.subtitle": "All orders",
+  "orders.list.search": "Search orders...",
+  "orders.list.noOrders": "No orders found",
+  "orders.source.dine_in": "Dine-in",
+  "orders.source.takeout": "Takeout",
+  "orders.source.ifood": "iFood",
+  "orders.source.99food": "99Food",
+  "orders.source.delivery": "Delivery",
+  "orders.settings.title": "Orders Settings"
+};
+
+// src/locales/pt-BR.ts
+var ptBR = {
+  "orders.title": "Pedidos",
+  "orders.nav.kanban": "Pedidos",
+  "orders.nav.list": "Hist\xF3rico",
+  "orders.nav.new": "Novo Pedido",
+  "orders.nav.dashboard": "Painel",
+  "orders.kanban.title": "Pedidos",
+  "orders.kanban.subtitle": "Pedidos ativos",
+  "orders.kanban.noOrders": "Nenhum pedido ativo",
+  "orders.kanban.noOrdersDesc": "Os pedidos aparecer\xE3o aqui conforme chegarem",
+  "orders.kanban.newOrder": "Novo Pedido",
+  "orders.kanban.advance": "Avan\xE7ar",
+  "orders.kanban.cancel": "Cancelar Pedido",
+  "orders.kanban.column.new": "Novo",
+  "orders.kanban.column.confirmed": "Confirmado",
+  "orders.kanban.column.preparing": "Preparando",
+  "orders.kanban.column.ready": "Pronto",
+  "orders.kanban.column.out": "Saiu",
+  "orders.kanban.column.completed": "Conclu\xEDdo",
+  "orders.kanban.column.cancelled": "Cancelado",
+  "orders.detail.title": "Detalhes do Pedido",
+  "orders.detail.items": "Itens",
+  "orders.detail.table": "Mesa",
+  "orders.detail.customer": "Cliente",
+  "orders.detail.waiter": "Gar\xE7om",
+  "orders.detail.source": "Origem",
+  "orders.detail.subtotal": "Subtotal",
+  "orders.detail.discount": "Desconto",
+  "orders.detail.tax": "Imposto",
+  "orders.detail.total": "Total",
+  "orders.detail.notes": "Observa\xE7\xF5es",
+  "orders.newOrder.title": "Novo Pedido",
+  "orders.newOrder.selectKind": "Tipo de pedido",
+  "orders.newOrder.dineIn": "Mesa",
+  "orders.newOrder.takeout": "Para Viagem",
+  "orders.newOrder.delivery": "Delivery",
+  "orders.newOrder.selectTable": "Selecionar mesa",
+  "orders.newOrder.addItems": "Adicionar itens",
+  "orders.newOrder.searchItems": "Buscar no card\xE1pio...",
+  "orders.newOrder.noItems": "Nenhum item adicionado",
+  "orders.newOrder.confirm": "Fazer Pedido",
+  "orders.newOrder.cancel": "Cancelar",
+  "orders.list.title": "Hist\xF3rico de Pedidos",
+  "orders.list.subtitle": "Todos os pedidos",
+  "orders.list.search": "Buscar pedidos...",
+  "orders.list.noOrders": "Nenhum pedido encontrado",
+  "orders.source.dine_in": "Mesa",
+  "orders.source.takeout": "Para Viagem",
+  "orders.source.ifood": "iFood",
+  "orders.source.99food": "99Food",
+  "orders.source.delivery": "Delivery",
+  "orders.settings.title": "Configura\xE7\xF5es de Pedidos"
+};
+
+// src/locales/index.ts
+var ordersLocales = { en, "pt-BR": ptBR };
+var DEFAULT_ORDERS_TABLE = "orders";
+var DEFAULT_ORDER_ITEMS_TABLE = "order_items";
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["new", "confirmed", "preparing", "ready", "served", "dispatched"]);
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function numberValue(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return Number(value) || 0;
+  return 0;
+}
+function dateKey(value) {
+  return value.slice(0, 10);
+}
+function referenceNumber() {
+  return `ORD-${Date.now().toString().slice(-6)}`;
+}
+function itemToRow(item, orderId, sortOrder) {
+  const discount = item.discount ?? 0;
+  return {
+    order_id: orderId,
+    product_id: item.productId ?? null,
+    name: item.name,
+    quantity: item.quantity,
+    unit_price: item.unitPrice,
+    discount,
+    total: item.quantity * item.unitPrice - discount,
+    sort_order: sortOrder,
+    modifiers: item.modifiers ?? null,
+    kitchen_notes: item.kitchenNotes ?? null
+  };
+}
+function rowToItem(row) {
+  const quantity = numberValue(row.quantity);
+  const unitPrice = numberValue(row.unit_price);
+  const discount = numberValue(row.discount);
+  return {
+    id: row.id,
+    orderId: row.order_id ?? "",
+    productId: row.product_id ?? void 0,
+    name: row.name ?? "Item",
+    description: row.description ?? void 0,
+    quantity,
+    unitPrice,
+    discount,
+    total: numberValue(row.total) || quantity * unitPrice - discount,
+    sortOrder: row.sort_order ?? 0,
+    modifiers: row.modifiers ?? void 0,
+    kitchenNotes: row.kitchen_notes ?? void 0,
+    metadata: row.metadata ?? {},
+    createdAt: row.created_at ?? nowIso()
+  };
+}
+function rowToOrder(row, items = []) {
+  const subtotal = numberValue(row.subtotal) || items.reduce((sum, item) => sum + item.total, 0);
+  const discount = numberValue(row.discount);
+  const tax = numberValue(row.tax);
+  return {
+    id: row.id,
+    referenceNumber: row.reference_number ?? row.id,
+    kind: row.kind ?? "dine_in",
+    status: row.status ?? "new",
+    partyId: row.party_id ?? void 0,
+    partyName: row.party_name ?? void 0,
+    assigneeId: row.assignee_id ?? void 0,
+    assigneeName: row.assignee_name ?? void 0,
+    locationId: row.location_id ?? void 0,
+    subtotal,
+    discount,
+    tax,
+    total: numberValue(row.total) || subtotal - discount + tax,
+    currency: row.currency ?? "BRL",
+    notes: row.notes ?? void 0,
+    tags: row.tags ?? [],
+    source: row.source ?? "pos",
+    tableId: row.table_id ?? void 0,
+    tableName: row.table_name ?? void 0,
+    estimatedMinutes: row.estimated_minutes ?? void 0,
+    items,
+    metadata: row.metadata ?? {},
+    tenantId: row.tenant_id ?? "runtime-tenant",
+    createdAt: row.created_at ?? nowIso(),
+    updatedAt: row.updated_at ?? row.created_at ?? nowIso(),
+    completedAt: row.completed_at ?? void 0
+  };
+}
+function orderPayload(input) {
+  const subtotal = input.items.reduce((sum, item) => sum + item.quantity * item.unitPrice - (item.discount ?? 0), 0);
+  return {
+    reference_number: referenceNumber(),
+    kind: input.kind,
+    status: "new",
+    source: input.source ?? "pos",
+    table_id: input.tableId ?? null,
+    party_id: input.partyId ?? null,
+    assignee_id: input.assigneeId ?? null,
+    notes: input.notes ?? null,
+    estimated_minutes: input.estimatedMinutes ?? null,
+    subtotal,
+    discount: 0,
+    tax: 0,
+    total: subtotal,
+    currency: "BRL",
+    tags: []
+  };
+}
+function updatePayload(data) {
+  const payload = {};
+  if (data.referenceNumber !== void 0) payload.reference_number = data.referenceNumber;
+  if (data.kind !== void 0) payload.kind = data.kind;
+  if (data.status !== void 0) payload.status = data.status;
+  if (data.partyId !== void 0) payload.party_id = data.partyId;
+  if (data.partyName !== void 0) payload.party_name = data.partyName;
+  if (data.assigneeId !== void 0) payload.assignee_id = data.assigneeId;
+  if (data.assigneeName !== void 0) payload.assignee_name = data.assigneeName;
+  if (data.locationId !== void 0) payload.location_id = data.locationId;
+  if (data.subtotal !== void 0) payload.subtotal = data.subtotal;
+  if (data.discount !== void 0) payload.discount = data.discount;
+  if (data.tax !== void 0) payload.tax = data.tax;
+  if (data.total !== void 0) payload.total = data.total;
+  if (data.currency !== void 0) payload.currency = data.currency;
+  if (data.notes !== void 0) payload.notes = data.notes;
+  if (data.tags !== void 0) payload.tags = data.tags;
+  if (data.source !== void 0) payload.source = data.source;
+  if (data.tableId !== void 0) payload.table_id = data.tableId;
+  if (data.tableName !== void 0) payload.table_name = data.tableName;
+  if (data.estimatedMinutes !== void 0) payload.estimated_minutes = data.estimatedMinutes;
+  if (data.metadata !== void 0) payload.metadata = data.metadata;
+  if (data.completedAt !== void 0) payload.completed_at = data.completedAt;
+  return payload;
+}
+function filtersFromQuery(query) {
+  const filters = [];
+  if (query.kind && !Array.isArray(query.kind)) filters.push({ column: "kind", operator: "eq", value: query.kind });
+  if (query.status && !Array.isArray(query.status)) filters.push({ column: "status", operator: "eq", value: query.status });
+  if (query.source) filters.push({ column: "source", operator: "eq", value: query.source });
+  if (query.tableId) filters.push({ column: "table_id", operator: "eq", value: query.tableId });
+  if (query.assigneeId) filters.push({ column: "assignee_id", operator: "eq", value: query.assigneeId });
+  return filters;
+}
+function matchesClientQuery(order, query) {
+  if (Array.isArray(query.kind) && !query.kind.includes(order.kind)) return false;
+  if (Array.isArray(query.status) && !query.status.includes(order.status)) return false;
+  if (query.dateRange) {
+    const created = dateKey(order.createdAt);
+    if (created < query.dateRange.from || created > query.dateRange.to) return false;
+  }
+  if (query.search) {
+    const search = query.search.toLowerCase();
+    return order.referenceNumber.toLowerCase().includes(search) || (order.partyName?.toLowerCase().includes(search) ?? false) || (order.tableName?.toLowerCase().includes(search) ?? false) || order.items.some((item) => item.name.toLowerCase().includes(search));
+  }
+  return true;
+}
+function paginate(items, page, pageSize) {
+  const currentPage = page ?? 1;
+  const limit = pageSize ?? 20;
+  const start = (currentPage - 1) * limit;
+  return { data: items.slice(start, start + limit), total: items.length };
+}
+function summarize(orders, dateRange) {
+  const today = dateKey(nowIso());
+  const from = dateRange?.from ?? today;
+  const to = dateRange?.to ?? today;
+  const inRange = orders.filter((order) => {
+    const created = dateKey(order.createdAt);
+    return created >= from && created <= to;
+  });
+  const billable = inRange.filter((order) => order.status !== "cancelled");
+  const revenue = billable.reduce((sum, order) => sum + order.total, 0);
+  const ordersByKind = { dine_in: 0, takeout: 0, delivery: 0 };
+  const ordersByStatus = {};
+  const top = /* @__PURE__ */ new Map();
+  for (const order of inRange) {
+    ordersByKind[order.kind] = (ordersByKind[order.kind] ?? 0) + 1;
+    ordersByStatus[order.status] = (ordersByStatus[order.status] ?? 0) + 1;
+    if (order.status === "cancelled") continue;
+    for (const item of order.items) {
+      const current = top.get(item.name) ?? { name: item.name, quantity: 0, revenue: 0 };
+      current.quantity += item.quantity;
+      current.revenue += item.total;
+      top.set(item.name, current);
+    }
+  }
+  return {
+    todayOrderCount: inRange.length,
+    todayRevenue: revenue,
+    averageTicket: billable.length > 0 ? revenue / billable.length : 0,
+    activeOrderCount: orders.filter((order) => ACTIVE_STATUSES.has(order.status)).length,
+    ordersByKind,
+    ordersByStatus,
+    topItems: [...top.values()].sort((a, b) => b.quantity - a.quantity).slice(0, 5)
+  };
+}
+function createFayzOrdersProvider(options = {}) {
+  const client = createFayzClient(options);
+  const ordersTable = options.ordersTable ?? DEFAULT_ORDERS_TABLE;
+  const orderItemsTable = options.orderItemsTable ?? DEFAULT_ORDER_ITEMS_TABLE;
+  const tableOptions = { projectId: options.projectId, schema: options.schema, runtime: options.runtime };
+  function resolveTenant() {
+    const value = typeof options.tenantId === "function" ? options.tenantId() : options.tenantId;
+    return value ?? void 0;
+  }
+  function withTenant(filters) {
+    const tenantId = resolveTenant();
+    return tenantId ? [{ column: "tenant_id", operator: "eq", value: tenantId }, ...filters] : filters;
+  }
+  async function listItemRows(orderIds) {
+    if (orderIds.length === 0) return [];
+    const rows = [];
+    await Promise.all(orderIds.map(async (orderId) => {
+      const response = await client.data.listRows({
+        ...tableOptions,
+        table: orderItemsTable,
+        filters: [{ column: "order_id", operator: "eq", value: orderId }],
+        sortColumn: "sort_order",
+        sortDirection: "asc",
+        limit: 200
+      });
+      rows.push(...response.rows);
+    }));
+    return rows;
+  }
+  async function hydrate(rows) {
+    const itemRows = await listItemRows(rows.map((row) => row.id));
+    const byOrder = /* @__PURE__ */ new Map();
+    for (const itemRow of itemRows) {
+      const item = rowToItem(itemRow);
+      const list = byOrder.get(item.orderId) ?? [];
+      list.push(item);
+      byOrder.set(item.orderId, list);
+    }
+    return rows.map((row) => rowToOrder(row, byOrder.get(row.id) ?? []));
+  }
+  async function listOrders(query = {}) {
+    const response = await client.data.listRows({
+      ...tableOptions,
+      table: ordersTable,
+      filters: withTenant(filtersFromQuery(query)),
+      sortColumn: "created_at",
+      sortDirection: "desc",
+      limit: 500
+    });
+    return (await hydrate(response.rows)).filter((order) => matchesClientQuery(order, query));
+  }
+  async function getById(id) {
+    const response = await client.data.listRows({
+      ...tableOptions,
+      table: ordersTable,
+      filters: withTenant([{ column: "id", operator: "eq", value: id }]),
+      limit: 1
+    });
+    return (await hydrate(response.rows))[0] ?? null;
+  }
+  return {
+    async getOrders(query) {
+      const orders = await listOrders(query);
+      return paginate(orders, query.page, query.pageSize);
+    },
+    async getOrderById(id) {
+      return getById(id);
+    },
+    async createOrder(input) {
+      const tenantId = resolveTenant();
+      const orderRow = await client.data.createRow({
+        ...tableOptions,
+        table: ordersTable,
+        row: tenantId ? { ...orderPayload(input), tenant_id: tenantId } : orderPayload(input)
+      });
+      await Promise.all(input.items.map((item, index) => client.data.createRow({
+        ...tableOptions,
+        table: orderItemsTable,
+        row: itemToRow(item, orderRow.id, index)
+      })));
+      return await getById(orderRow.id) ?? rowToOrder(orderRow);
+    },
+    async updateOrderStatus(input) {
+      const completedAt = input.status === "completed" ? nowIso() : void 0;
+      return this.updateOrder(input.orderId, { status: input.status, completedAt });
+    },
+    async updateOrder(id, data) {
+      const row = await client.data.updateRow({
+        ...tableOptions,
+        table: ordersTable,
+        primaryKeys: { id },
+        row: updatePayload(data)
+      });
+      return await getById(row.id) ?? rowToOrder(row);
+    },
+    async cancelOrder(id, reason) {
+      const order = await getById(id);
+      await this.updateOrder(id, {
+        status: "cancelled",
+        notes: reason ? `${order?.notes ? `${order.notes}
+` : ""}Cancelled: ${reason}` : order?.notes
+      });
+    },
+    async addOrderItem(orderId, item) {
+      const order = await getById(orderId);
+      const row = await client.data.createRow({
+        ...tableOptions,
+        table: orderItemsTable,
+        row: itemToRow(item, orderId, order?.items.length ?? 0)
+      });
+      const created = rowToItem(row);
+      const items = [...order?.items ?? [], created];
+      await this.updateOrder(orderId, {
+        subtotal: items.reduce((sum, orderItem) => sum + orderItem.total, 0),
+        total: items.reduce((sum, orderItem) => sum + orderItem.total, 0) - (order?.discount ?? 0) + (order?.tax ?? 0)
+      });
+      return created;
+    },
+    async removeOrderItem(itemId) {
+      const orders = await listOrders();
+      const order = orders.find((item) => item.items.some((orderItem) => orderItem.id === itemId));
+      await client.data.deleteRows({ ...tableOptions, table: orderItemsTable, rows: [{ id: itemId }] });
+      if (order) {
+        const items = order.items.filter((item) => item.id !== itemId);
+        const subtotal = items.reduce((sum, item) => sum + item.total, 0);
+        await this.updateOrder(order.id, { subtotal, total: subtotal - order.discount + order.tax });
+      }
+    },
+    async updateOrderItem(itemId, data) {
+      const row = await client.data.updateRow({
+        ...tableOptions,
+        table: orderItemsTable,
+        primaryKeys: { id: itemId },
+        row: {
+          product_id: data.productId,
+          name: data.name,
+          description: data.description,
+          quantity: data.quantity,
+          unit_price: data.unitPrice,
+          discount: data.discount,
+          total: data.total,
+          sort_order: data.sortOrder,
+          modifiers: data.modifiers,
+          kitchen_notes: data.kitchenNotes,
+          metadata: data.metadata
+        }
+      });
+      return rowToItem(row);
+    },
+    async getSummary(dateRange) {
+      return summarize(await listOrders({ dateRange }), dateRange);
+    }
+  };
+}
+
+// src/index.ts
+var OrdersPage = React.lazy(() => import('./OrdersPage-LJIEIZYE.js').then((m) => ({ default: m.OrdersPage })));
+var DEFAULT_LABELS = {
+  pageTitle: "Orders",
+  kanban: "Orders",
+  newOrder: "New Order",
+  orderList: "History"
+};
+var DEFAULT_CURRENCY = { code: "BRL", locale: "pt-BR", symbol: "R$" };
+var DEFAULT_ORDER_SOURCES = [
+  { value: "dine_in", label: "Dine-in", icon: "\u{1F37D}\uFE0F" },
+  { value: "takeout", label: "Takeout", icon: "\u{1F961}" }
+];
+function resolveConfig(options) {
+  return {
+    modules: {
+      delivery: options?.modules?.delivery !== false,
+      takeout: options?.modules?.takeout !== false
+    },
+    labels: { ...DEFAULT_LABELS, ...options?.labels },
+    currency: { ...DEFAULT_CURRENCY, ...options?.currency },
+    orderSources: options?.orderSources ?? DEFAULT_ORDER_SOURCES,
+    menuItemLookup: options?.menuItemLookup,
+    staffLookup: options?.staffLookup,
+    onOrderCompleted: options?.onOrderCompleted
+  };
+}
+function createOrdersPlugin(options) {
+  const config = resolveConfig(options);
+  const provider = options?.dataProvider ?? createMockOrdersProvider();
+  const store = createOrdersStore(provider);
+  const PageComponent = () => React.createElement(
+    React.Suspense,
+    { fallback: null },
+    React.createElement(OrdersPage, { config, provider, store, registries: ordersRegistries })
+  );
+  return {
+    id: "orders",
+    name: config.labels.pageTitle,
+    icon: "ClipboardList",
+    version: "1.0.0",
+    scope: options?.scope ?? "vertical",
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: ["menu"],
+    navigation: [
+      {
+        section: options?.navSection ?? "main",
+        position: options?.navPosition ?? 2,
+        label: config.labels.pageTitle,
+        route: "/orders",
+        icon: "ClipboardList",
+        permission: { feature: "orders", action: "read" }
+      }
+    ],
+    routes: [
+      {
+        path: "/orders",
+        component: PageComponent,
+        permission: { feature: "orders", action: "read" }
+      }
+    ],
+    widgets: [],
+    aiTools: [
+      {
+        id: "orders.today-summary",
+        name: "getOrdersSummary",
+        description: "Returns order count, revenue, and average ticket for today or a given period.",
+        icon: "ClipboardList",
+        mode: "read",
+        category: "Orders",
+        parameters: {
+          type: "object",
+          properties: {
+            period: { type: "string", description: "today, week, month" }
+          }
+        },
+        suggestions: [
+          { label: "How many orders today?" },
+          { label: "What's the average ticket today?" },
+          { label: "What's the most ordered item?" }
+        ]
+      },
+      {
+        id: "orders.active-orders",
+        name: "getActiveOrders",
+        description: "Lists currently active (non-completed) orders.",
+        icon: "Clock",
+        mode: "read",
+        category: "Orders",
+        parameters: {
+          type: "object",
+          properties: {
+            kind: { type: "string", enum: ["dine_in", "takeout", "delivery"] },
+            status: { type: "string", description: "Filter by status" }
+          }
+        },
+        suggestions: [
+          { label: "What orders are being prepared right now?" },
+          { label: "Any delivery orders waiting?" }
+        ]
+      },
+      {
+        id: "orders.create-order",
+        name: "createOrder",
+        description: "Creates a new restaurant order with items.",
+        icon: "PlusCircle",
+        mode: "persist",
+        category: "Orders",
+        parameters: {
+          type: "object",
+          properties: {
+            kind: { type: "string", enum: ["dine_in", "takeout", "delivery"] },
+            tableNumber: { type: "number", description: "Table number (for dine-in)" },
+            items: { type: "array", description: "Item names and quantities" }
+          },
+          required: ["kind", "items"]
+        },
+        permission: { feature: "orders", action: "create" }
+      }
+    ],
+    registries: ordersRegistries,
+    settings: [
+      {
+        id: "orders",
+        label: config.labels.pageTitle,
+        icon: "ClipboardList",
+        component: (() => {
+          const OrdersSettingsTab = () => React.createElement(PluginSettingsPanel, {
+            title: "Orders Settings",
+            subtitle: "Order sources and preferences",
+            registries: ordersRegistries,
+            routeBase: "/settings/orders"
+          });
+          OrdersSettingsTab.displayName = "OrdersSettingsTab";
+          return OrdersSettingsTab;
+        })(),
+        order: 22,
+        permission: { feature: "orders", action: "read" }
+      }
+    ],
+    locales: ordersLocales
+  };
+}
+
+export { createFayzOrdersProvider, createOrdersPlugin };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map