@fayz-ai/plugin-tables 0.2.0

package/dist/index.cjs

@@ -0,0 +1,887 @@
+'use strict';
+
+var React = require('react');
+var vanilla = require('zustand/vanilla');
+var saas = require('@fayz-ai/saas');
+var sonner = require('sonner');
+var sdk = require('@fayz-ai/sdk');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/index.ts
+
+// src/data/mock.ts
+var uid = 0;
+function nextId(prefix) {
+  return prefix + "-" + ++uid;
+}
+var TENANT = "mock-tenant";
+var NOW = (/* @__PURE__ */ new Date()).toISOString();
+function makeTable(id, number, seats, zone, zoneName, shape, gridCol, gridRow) {
+  return {
+    id,
+    name: `Table ${number}`,
+    number,
+    seats,
+    status: "available",
+    zone,
+    zoneName,
+    shape,
+    gridCol,
+    gridRow,
+    isActive: true,
+    tenantId: TENANT,
+    createdAt: NOW,
+    updatedAt: NOW
+  };
+}
+function seedZones() {
+  return [
+    { id: nextId("zone"), name: "Indoor", color: "#3b82f6", sortOrder: 0, isActive: true, tenantId: TENANT, createdAt: NOW },
+    { id: nextId("zone"), name: "Outdoor", color: "#22c55e", sortOrder: 1, isActive: true, tenantId: TENANT, createdAt: NOW },
+    { id: nextId("zone"), name: "Bar", color: "#f59e0b", sortOrder: 2, isActive: true, tenantId: TENANT, createdAt: NOW }
+  ];
+}
+function seedTables(zones) {
+  const [indoor, outdoor, bar] = zones;
+  const tables = [];
+  for (let i = 0; i < 8; i++) {
+    const num = i + 1;
+    tables.push(makeTable(
+      nextId("table"),
+      num,
+      i % 2 === 0 ? 4 : 6,
+      indoor.id,
+      indoor.name,
+      i % 2 === 0 ? "square" : "rectangle",
+      i % 4,
+      Math.floor(i / 4)
+    ));
+  }
+  tables.push(makeTable(nextId("table"), 9, 4, outdoor.id, outdoor.name, "round", 0, 0));
+  tables.push(makeTable(nextId("table"), 10, 4, outdoor.id, outdoor.name, "round", 1, 0));
+  tables.push(makeTable(nextId("table"), 11, 2, bar.id, bar.name, "bar", 0, 0));
+  tables.push(makeTable(nextId("table"), 12, 2, bar.id, bar.name, "bar", 1, 0));
+  return tables;
+}
+function createMockTablesProvider() {
+  const zones = seedZones();
+  const tables = seedTables(zones);
+  const sessions = [];
+  function findTable(id) {
+    return tables.find((t) => t.id === id) ?? null;
+  }
+  function matchesQuery(table, query) {
+    if (!query) return true;
+    if (query.zone && table.zone !== query.zone) return false;
+    if (query.status) {
+      const statuses = Array.isArray(query.status) ? query.status : [query.status];
+      if (!statuses.includes(table.status)) return false;
+    }
+    if (query.search) {
+      const s = query.search.toLowerCase();
+      if (!table.name.toLowerCase().includes(s) && !String(table.number).includes(s) && !(table.zoneName ?? "").toLowerCase().includes(s)) return false;
+    }
+    return true;
+  }
+  return {
+    // ---- Tables ----
+    async getTables(query) {
+      return tables.filter((t) => matchesQuery(t, query));
+    },
+    async getTableById(id) {
+      return findTable(id);
+    },
+    async createTable(input) {
+      const zone = zones.find((z) => z.id === input.zone);
+      const table = {
+        id: nextId("table"),
+        name: input.name,
+        number: input.number,
+        seats: input.seats,
+        status: "available",
+        zone: input.zone,
+        zoneName: zone?.name,
+        shape: input.shape ?? "square",
+        gridCol: input.gridCol ?? 0,
+        gridRow: input.gridRow ?? 0,
+        isActive: true,
+        tenantId: TENANT,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      tables.push(table);
+      return table;
+    },
+    async updateTable(id, data) {
+      const table = findTable(id);
+      if (!table) throw new Error(`Table ${id} not found`);
+      Object.assign(table, data, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      return table;
+    },
+    async deleteTable(id) {
+      const idx = tables.findIndex((t) => t.id === id);
+      if (idx !== -1) tables.splice(idx, 1);
+    },
+    async updateTableStatus(input) {
+      const table = findTable(input.tableId);
+      if (!table) throw new Error(`Table ${input.tableId} not found`);
+      table.status = input.status;
+      table.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return table;
+    },
+    async updateTablePositions(positions) {
+      for (const pos of positions) {
+        const table = findTable(pos.id);
+        if (table) {
+          table.gridCol = pos.gridCol;
+          table.gridRow = pos.gridRow;
+          table.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+    },
+    // ---- Sessions ----
+    async seatGuests(input) {
+      const table = findTable(input.tableId);
+      if (!table) throw new Error(`Table ${input.tableId} not found`);
+      const session = {
+        id: nextId("session"),
+        tableId: input.tableId,
+        tableName: table.name,
+        guests: input.guests,
+        waiterId: input.waiterId,
+        waiterName: input.waiterId ? `Waiter ${input.waiterId}` : void 0,
+        seatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "active",
+        notes: input.notes,
+        tenantId: TENANT,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      sessions.push(session);
+      table.status = "occupied";
+      table.currentSessionId = session.id;
+      table.currentGuests = input.guests;
+      table.currentWaiterName = session.waiterName;
+      table.currentElapsedMinutes = 0;
+      table.currentTotal = 0;
+      table.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return session;
+    },
+    async closeSession(sessionId) {
+      const session = sessions.find((s) => s.id === sessionId);
+      if (!session) throw new Error(`Session ${sessionId} not found`);
+      session.status = "closed";
+      session.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const table = findTable(session.tableId);
+      if (table) {
+        table.status = "cleaning";
+        table.currentSessionId = void 0;
+        table.currentOrderId = void 0;
+        table.currentGuests = void 0;
+        table.currentWaiterName = void 0;
+        table.currentElapsedMinutes = void 0;
+        table.currentTotal = void 0;
+        table.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return session;
+    },
+    async getActiveSessions() {
+      return sessions.filter((s) => s.status === "active");
+    },
+    async getSessionHistory(tableId) {
+      const closed = sessions.filter((s) => s.status === "closed");
+      if (tableId) return closed.filter((s) => s.tableId === tableId);
+      return closed;
+    },
+    // ---- Zones ----
+    async getZones() {
+      return [...zones];
+    },
+    async createZone(data) {
+      const zone = {
+        id: nextId("zone"),
+        name: data.name ?? "New Zone",
+        color: data.color,
+        sortOrder: data.sortOrder ?? zones.length,
+        isActive: data.isActive ?? true,
+        tenantId: TENANT,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      zones.push(zone);
+      return zone;
+    },
+    async updateZone(id, data) {
+      const zone = zones.find((z) => z.id === id);
+      if (!zone) throw new Error(`Zone ${id} not found`);
+      Object.assign(zone, data);
+      return zone;
+    },
+    async deleteZone(id) {
+      const idx = zones.findIndex((z) => z.id === id);
+      if (idx !== -1) zones.splice(idx, 1);
+    },
+    // ---- Summary ----
+    async getSummary() {
+      const available = tables.filter((t) => t.status === "available").length;
+      const occupied = tables.filter((t) => t.status === "occupied").length;
+      const reserved = tables.filter((t) => t.status === "reserved").length;
+      const cleaning = tables.filter((t) => t.status === "cleaning").length;
+      const totalSeats = tables.reduce((sum, t) => sum + t.seats, 0);
+      const occupiedSeats = tables.filter((t) => t.status === "occupied").reduce((sum, t) => sum + (t.currentGuests ?? t.seats), 0);
+      const closedSessions = sessions.filter((s) => s.status === "closed" && s.closedAt);
+      let averageSessionMinutes = 0;
+      if (closedSessions.length > 0) {
+        const totalMinutes = closedSessions.reduce((sum, s) => {
+          const seated = new Date(s.seatedAt).getTime();
+          const closed = new Date(s.closedAt).getTime();
+          return sum + (closed - seated) / 6e4;
+        }, 0);
+        averageSessionMinutes = Math.round(totalMinutes / closedSessions.length);
+      }
+      return {
+        totalTables: tables.length,
+        availableCount: available,
+        occupiedCount: occupied,
+        reservedCount: reserved,
+        cleaningCount: cleaning,
+        totalSeats,
+        occupiedSeats,
+        averageSessionMinutes
+      };
+    }
+  };
+}
+function createTablesStore(provider) {
+  return vanilla.createStore((set, get) => ({
+    tables: [],
+    tablesLoading: false,
+    zones: [],
+    zonesLoading: false,
+    activeSessions: [],
+    sessionsLoading: false,
+    sessionHistory: [],
+    historyLoading: false,
+    summary: null,
+    summaryLoading: false,
+    selectedTableId: null,
+    async fetchTables(query) {
+      return saas.dedup("tables:tables:" + JSON.stringify(query), async () => {
+        set({ tablesLoading: true });
+        const tables = await provider.getTables(query);
+        set({ tables, tablesLoading: false });
+      });
+    },
+    async fetchZones() {
+      return saas.dedup("tables:zones", async () => {
+        set({ zonesLoading: true });
+        const zones = await provider.getZones();
+        set({ zones, zonesLoading: false });
+      });
+    },
+    async fetchActiveSessions() {
+      return saas.dedup("tables:activeSessions", async () => {
+        set({ sessionsLoading: true });
+        const activeSessions = await provider.getActiveSessions();
+        set({ activeSessions, sessionsLoading: false });
+      });
+    },
+    async fetchSessionHistory(tableId) {
+      return saas.dedup("tables:history:" + (tableId ?? ""), async () => {
+        set({ historyLoading: true });
+        const sessionHistory = await provider.getSessionHistory(tableId);
+        set({ sessionHistory, historyLoading: false });
+      });
+    },
+    async fetchSummary() {
+      return saas.dedup("tables:summary", async () => {
+        set({ summaryLoading: true });
+        const summary = await provider.getSummary();
+        set({ summary, summaryLoading: false });
+      });
+    },
+    selectTable(id) {
+      set({ selectedTableId: id });
+    },
+    async seatGuests(input) {
+      try {
+        const session = await provider.seatGuests(input);
+        const [tables, activeSessions, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getActiveSessions(),
+          provider.getSummary()
+        ]);
+        set({ tables, activeSessions, summary });
+        sonner.toast.success("Guests seated");
+        return session;
+      } catch (err) {
+        sonner.toast.error("Failed to seat guests", { description: err?.message });
+        throw err;
+      }
+    },
+    async closeSession(sessionId) {
+      try {
+        await provider.closeSession(sessionId);
+        const [tables, activeSessions, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getActiveSessions(),
+          provider.getSummary()
+        ]);
+        set({ tables, activeSessions, summary });
+        sonner.toast.success("Session closed");
+      } catch (err) {
+        sonner.toast.error("Failed to close session", { description: err?.message });
+        throw err;
+      }
+    },
+    async updateTableStatus(input) {
+      try {
+        await provider.updateTableStatus(input);
+        const [tables, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getSummary()
+        ]);
+        set({ tables, summary });
+        sonner.toast.success("Table status updated");
+      } catch (err) {
+        sonner.toast.error("Failed to update table status", { description: err?.message });
+        throw err;
+      }
+    },
+    async createTable(input) {
+      try {
+        const table = await provider.createTable(input);
+        const [tables, summary] = await Promise.all([
+          provider.getTables(),
+          provider.getSummary()
+        ]);
+        set({ tables, summary });
+        sonner.toast.success("Table created");
+        return table;
+      } catch (err) {
+        sonner.toast.error("Failed to create table", { description: err?.message });
+        throw err;
+      }
+    }
+  }));
+}
+
+// src/registries.ts
+var zoneEntity = {
+  name: "Zone",
+  namePlural: "Zones",
+  icon: "MapPin",
+  displayField: "name",
+  defaultSort: "sortOrder",
+  fields: [
+    { key: "name", label: "Name", type: "text", required: true, showInTable: true },
+    { key: "color", label: "Color", type: "text", showInTable: true },
+    { key: "sortOrder", label: "Order", type: "number", showInTable: true, defaultValue: 0 },
+    { key: "isActive", label: "Active", type: "boolean", showInTable: true, defaultValue: true }
+  ],
+  data: { table: "restaurant_zones", tenantScoped: true }
+};
+var tablesRegistries = [
+  {
+    id: "zones",
+    entity: zoneEntity,
+    icon: "MapPin",
+    description: "Floor plan zones (indoor, outdoor, bar, etc.)",
+    display: "table",
+    seedData: [
+      { id: "z-indoor", name: "Indoor", color: "#3b82f6", sortOrder: 0, isActive: true },
+      { id: "z-outdoor", name: "Outdoor", color: "#22c55e", sortOrder: 1, isActive: true },
+      { id: "z-bar", name: "Bar", color: "#f59e0b", sortOrder: 2, isActive: true }
+    ]
+  }
+];
+
+// src/locales/en.ts
+var en = {
+  "tables.title": "Tables",
+  "tables.nav.floorPlan": "Floor Plan",
+  "tables.nav.zones": "Zones",
+  "tables.nav.history": "Session History",
+  "tables.floorPlan.title": "Floor Plan",
+  "tables.floorPlan.subtitle": "Manage table layout and seating",
+  "tables.floorPlan.available": "Available",
+  "tables.floorPlan.occupied": "Occupied",
+  "tables.floorPlan.reserved": "Reserved",
+  "tables.floorPlan.cleaning": "Cleaning",
+  "tables.floorPlan.seats": "seats",
+  "tables.floorPlan.noTables": "No tables configured",
+  "tables.floorPlan.noTablesDesc": "Add your first table to get started",
+  "tables.floorPlan.addTable": "Add Table",
+  "tables.floorPlan.occupiedOf": "{occupied} occupied, {available} available of {total} tables",
+  "tables.floorPlan.selectTable": "Select a table",
+  "tables.floorPlan.selectTableDesc": "Click on any table to see details and actions",
+  "tables.floorPlan.min": "min",
+  "tables.floorPlan.zone": "Zone",
+  "tables.floorPlan.order": "Order",
+  "tables.floorPlan.checkIn": "Check In",
+  "tables.detail.currentSession": "Current Session",
+  "tables.detail.guests": "Guests",
+  "tables.detail.waiter": "Waiter",
+  "tables.detail.elapsed": "Elapsed",
+  "tables.detail.total": "Running Total",
+  "tables.detail.viewOrder": "View Order",
+  "tables.detail.seatGuests": "Seat Guests",
+  "tables.detail.closeTable": "Close Table",
+  "tables.detail.markClean": "Mark Ready",
+  "tables.detail.cancel": "Cancel",
+  "tables.seat.title": "Seat Guests",
+  "tables.seat.guestCount": "Number of guests",
+  "tables.seat.waiter": "Waiter",
+  "tables.seat.notes": "Notes",
+  "tables.seat.confirm": "Seat",
+  "tables.history.title": "Session History",
+  "tables.history.table": "Table",
+  "tables.history.guests": "Guests",
+  "tables.history.waiter": "Waiter",
+  "tables.history.duration": "Duration",
+  "tables.history.noSessions": "No session history yet",
+  "tables.settings.title": "Tables Settings"
+};
+
+// src/locales/pt-BR.ts
+var ptBR = {
+  "tables.title": "Mesas",
+  "tables.nav.floorPlan": "Mapa de Mesas",
+  "tables.nav.zones": "\xC1reas",
+  "tables.nav.history": "Hist\xF3rico",
+  "tables.floorPlan.title": "Mapa de Mesas",
+  "tables.floorPlan.subtitle": "Gerencie o layout e a ocupa\xE7\xE3o das mesas",
+  "tables.floorPlan.available": "Dispon\xEDvel",
+  "tables.floorPlan.occupied": "Ocupada",
+  "tables.floorPlan.reserved": "Reservada",
+  "tables.floorPlan.cleaning": "Limpeza",
+  "tables.floorPlan.seats": "lugares",
+  "tables.floorPlan.noTables": "Nenhuma mesa configurada",
+  "tables.floorPlan.noTablesDesc": "Adicione a primeira mesa para come\xE7ar",
+  "tables.floorPlan.addTable": "Adicionar Mesa",
+  "tables.floorPlan.occupiedOf": "{occupied} ocupadas, {available} dispon\xEDveis de {total} mesas",
+  "tables.floorPlan.selectTable": "Selecione uma mesa",
+  "tables.floorPlan.selectTableDesc": "Clique em uma mesa para ver detalhes e a\xE7\xF5es",
+  "tables.floorPlan.min": "min",
+  "tables.floorPlan.zone": "\xC1rea",
+  "tables.floorPlan.order": "Pedido",
+  "tables.floorPlan.checkIn": "Check-in",
+  "tables.detail.currentSession": "Sess\xE3o Atual",
+  "tables.detail.guests": "Pessoas",
+  "tables.detail.waiter": "Gar\xE7om",
+  "tables.detail.elapsed": "Tempo",
+  "tables.detail.total": "Total Parcial",
+  "tables.detail.viewOrder": "Ver Pedido",
+  "tables.detail.seatGuests": "Sentar Clientes",
+  "tables.detail.closeTable": "Fechar Mesa",
+  "tables.detail.markClean": "Marcar Pronta",
+  "tables.detail.cancel": "Cancelar",
+  "tables.seat.title": "Sentar Clientes",
+  "tables.seat.guestCount": "N\xFAmero de pessoas",
+  "tables.seat.waiter": "Gar\xE7om",
+  "tables.seat.notes": "Observa\xE7\xF5es",
+  "tables.seat.confirm": "Sentar",
+  "tables.history.title": "Hist\xF3rico de Sess\xF5es",
+  "tables.history.table": "Mesa",
+  "tables.history.guests": "Pessoas",
+  "tables.history.waiter": "Gar\xE7om",
+  "tables.history.duration": "Dura\xE7\xE3o",
+  "tables.history.noSessions": "Nenhum hist\xF3rico de sess\xF5es",
+  "tables.settings.title": "Configura\xE7\xF5es de Mesas"
+};
+
+// src/locales/index.ts
+var tablesLocales = { en, "pt-BR": ptBR };
+var DEFAULT_TABLE_NAME = "restaurant_tables";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function rowToTable(row) {
+  const number = row.number ?? 0;
+  const zone = row.zone ?? "indoor";
+  return {
+    id: row.id,
+    name: row.name ?? `Table ${number}`,
+    number,
+    seats: row.seats ?? 4,
+    status: row.status ?? "available",
+    zone,
+    zoneName: row.zone_name ?? zone,
+    shape: row.shape ?? "square",
+    gridCol: row.grid_col ?? 0,
+    gridRow: row.grid_row ?? 0,
+    isActive: row.is_active ?? true,
+    currentSessionId: row.current_session_id ?? void 0,
+    currentOrderId: row.current_order_id ?? void 0,
+    currentGuests: row.current_guests ?? void 0,
+    currentWaiterName: row.current_waiter_name ?? void 0,
+    currentElapsedMinutes: row.current_elapsed_minutes ?? void 0,
+    currentTotal: row.current_total ?? void 0,
+    metadata: row.metadata ?? {},
+    tenantId: row.tenant_id ?? "runtime-tenant",
+    createdAt: row.created_at ?? nowIso(),
+    updatedAt: row.updated_at ?? row.created_at ?? nowIso()
+  };
+}
+function tableCreatePayload(input) {
+  return {
+    name: input.name,
+    number: input.number,
+    seats: input.seats,
+    zone: input.zone,
+    shape: input.shape ?? "square",
+    grid_col: input.gridCol ?? 0,
+    grid_row: input.gridRow ?? 0,
+    status: "available",
+    is_active: true
+  };
+}
+function tableUpdatePayload(data) {
+  const payload = {};
+  if (data.name !== void 0) payload.name = data.name;
+  if (data.number !== void 0) payload.number = data.number;
+  if (data.seats !== void 0) payload.seats = data.seats;
+  if (data.status !== void 0) payload.status = data.status;
+  if (data.zone !== void 0) payload.zone = data.zone;
+  if (data.zoneName !== void 0) payload.zone_name = data.zoneName;
+  if (data.shape !== void 0) payload.shape = data.shape;
+  if (data.gridCol !== void 0) payload.grid_col = data.gridCol;
+  if (data.gridRow !== void 0) payload.grid_row = data.gridRow;
+  if (data.isActive !== void 0) payload.is_active = data.isActive;
+  if (data.currentSessionId !== void 0) payload.current_session_id = data.currentSessionId;
+  if (data.currentOrderId !== void 0) payload.current_order_id = data.currentOrderId;
+  if (data.currentGuests !== void 0) payload.current_guests = data.currentGuests;
+  if (data.currentWaiterName !== void 0) payload.current_waiter_name = data.currentWaiterName;
+  if (data.currentElapsedMinutes !== void 0) payload.current_elapsed_minutes = data.currentElapsedMinutes;
+  if (data.currentTotal !== void 0) payload.current_total = data.currentTotal;
+  if (data.metadata !== void 0) payload.metadata = data.metadata;
+  return payload;
+}
+function filtersFromQuery(query) {
+  const filters = [{ column: "is_active", operator: "eq", value: true }];
+  if (!query) return filters;
+  if (query.zone) filters.push({ column: "zone", operator: "eq", value: query.zone });
+  if (query.status && !Array.isArray(query.status)) {
+    filters.push({ column: "status", operator: "eq", value: query.status });
+  }
+  return filters;
+}
+function matchesClientQuery(table, query) {
+  if (!query) return true;
+  if (Array.isArray(query.status) && !query.status.includes(table.status)) return false;
+  if (query.search) {
+    const search = query.search.toLowerCase();
+    return table.name.toLowerCase().includes(search) || String(table.number).includes(search) || (table.zoneName?.toLowerCase().includes(search) ?? false);
+  }
+  return true;
+}
+function summarize(tables) {
+  const availableCount = tables.filter((table) => table.status === "available").length;
+  const occupiedCount = tables.filter((table) => table.status === "occupied").length;
+  const reservedCount = tables.filter((table) => table.status === "reserved").length;
+  const cleaningCount = tables.filter((table) => table.status === "cleaning").length;
+  const totalSeats = tables.reduce((sum, table) => sum + table.seats, 0);
+  const occupiedSeats = tables.filter((table) => table.status === "occupied").reduce((sum, table) => sum + (table.currentGuests ?? table.seats), 0);
+  return {
+    totalTables: tables.length,
+    availableCount,
+    occupiedCount,
+    reservedCount,
+    cleaningCount,
+    totalSeats,
+    occupiedSeats,
+    averageSessionMinutes: 0
+  };
+}
+function createFayzTablesProvider(options = {}) {
+  const client = sdk.createFayzClient(options);
+  const table = options.tableName ?? DEFAULT_TABLE_NAME;
+  const baseOptions = {
+    projectId: options.projectId,
+    table,
+    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 listTables(query) {
+    const response = await client.data.listRows({
+      ...baseOptions,
+      filters: withTenant(filtersFromQuery(query)),
+      sortColumn: "number",
+      sortDirection: "asc",
+      limit: 500
+    });
+    return response.rows.map(rowToTable).filter((item) => matchesClientQuery(item, query));
+  }
+  async function getById(id) {
+    const response = await client.data.listRows({
+      ...baseOptions,
+      filters: withTenant([{ column: "id", operator: "eq", value: id }]),
+      limit: 1
+    });
+    return response.rows[0] ? rowToTable(response.rows[0]) : null;
+  }
+  return {
+    async getTables(query) {
+      return listTables(query);
+    },
+    async getTableById(id) {
+      return getById(id);
+    },
+    async createTable(input) {
+      const tenantId = resolveTenant();
+      const row = await client.data.createRow({
+        ...baseOptions,
+        row: tenantId ? { ...tableCreatePayload(input), tenant_id: tenantId } : tableCreatePayload(input)
+      });
+      return rowToTable(row);
+    },
+    async updateTable(id, data) {
+      const row = await client.data.updateRow({
+        ...baseOptions,
+        primaryKeys: { id },
+        row: tableUpdatePayload(data)
+      });
+      return rowToTable(row);
+    },
+    async deleteTable(id) {
+      await client.data.deleteRows({ ...baseOptions, rows: [{ id }] });
+    },
+    async updateTableStatus(input) {
+      return this.updateTable(input.tableId, { status: input.status });
+    },
+    async updateTablePositions(positions) {
+      await Promise.all(positions.map((position) => this.updateTable(position.id, {
+        gridCol: position.gridCol,
+        gridRow: position.gridRow
+      })));
+    },
+    async seatGuests(input) {
+      const table2 = await this.updateTable(input.tableId, {
+        status: "occupied",
+        currentGuests: input.guests,
+        currentWaiterName: input.waiterId ? `Waiter ${input.waiterId}` : void 0,
+        currentElapsedMinutes: 0,
+        currentTotal: 0
+      });
+      const session = {
+        id: table2.currentSessionId ?? `runtime-session-${table2.id}`,
+        tableId: table2.id,
+        tableName: table2.name,
+        guests: input.guests,
+        waiterId: input.waiterId,
+        waiterName: table2.currentWaiterName,
+        seatedAt: nowIso(),
+        status: "active",
+        notes: input.notes,
+        tenantId: table2.tenantId,
+        createdAt: nowIso()
+      };
+      return session;
+    },
+    async closeSession(sessionId) {
+      const tables = await listTables();
+      const table2 = tables.find((item) => item.currentSessionId === sessionId);
+      if (table2) await this.updateTable(table2.id, {
+        status: "cleaning",
+        currentSessionId: void 0,
+        currentOrderId: void 0,
+        currentGuests: void 0,
+        currentWaiterName: void 0,
+        currentElapsedMinutes: void 0,
+        currentTotal: void 0
+      });
+      return {
+        id: sessionId,
+        tableId: table2?.id ?? "",
+        tableName: table2?.name,
+        guests: table2?.currentGuests ?? 0,
+        seatedAt: nowIso(),
+        closedAt: nowIso(),
+        status: "closed",
+        tenantId: table2?.tenantId ?? "runtime-tenant",
+        createdAt: nowIso()
+      };
+    },
+    async getActiveSessions() {
+      const tables = await listTables({ status: "occupied" });
+      return tables.map((table2) => ({
+        id: table2.currentSessionId ?? `runtime-session-${table2.id}`,
+        tableId: table2.id,
+        tableName: table2.name,
+        guests: table2.currentGuests ?? table2.seats,
+        waiterName: table2.currentWaiterName,
+        seatedAt: nowIso(),
+        status: "active",
+        tenantId: table2.tenantId,
+        createdAt: nowIso()
+      }));
+    },
+    async getSessionHistory() {
+      return [];
+    },
+    async getZones() {
+      const tables = await listTables();
+      const zones = /* @__PURE__ */ new Map();
+      for (const table2 of tables) {
+        if (zones.has(table2.zone)) continue;
+        zones.set(table2.zone, {
+          id: table2.zone,
+          name: table2.zoneName ?? table2.zone,
+          sortOrder: zones.size,
+          isActive: true,
+          tenantId: table2.tenantId,
+          createdAt: table2.createdAt
+        });
+      }
+      return [...zones.values()];
+    },
+    async createZone() {
+      throw new Error("Restaurant zone writes require a dedicated Fayz table/broker contract.");
+    },
+    async updateZone() {
+      throw new Error("Restaurant zone writes require a dedicated Fayz table/broker contract.");
+    },
+    async deleteZone() {
+      throw new Error("Restaurant zone writes require a dedicated Fayz table/broker contract.");
+    },
+    async getSummary() {
+      return summarize(await listTables());
+    }
+  };
+}
+
+// src/index.ts
+var TablesPage = React__default.default.lazy(() => import('./TablesPage-5GCFGSX3.cjs').then((m) => ({ default: m.TablesPage })));
+var DEFAULT_LABELS = {
+  pageTitle: "Tables",
+  floorPlan: "Floor Plan",
+  zones: "Zones",
+  sessionHistory: "Session History"
+};
+function resolveConfig(options) {
+  return {
+    modules: {
+      reservations: options?.modules?.reservations === true,
+      sessionHistory: options?.modules?.sessionHistory !== false
+    },
+    labels: { ...DEFAULT_LABELS, ...options?.labels },
+    defaultZones: options?.defaultZones ?? [
+      { name: "Indoor", color: "#3b82f6" },
+      { name: "Outdoor", color: "#22c55e" },
+      { name: "Bar", color: "#f59e0b" }
+    ],
+    onTableSeated: options?.onTableSeated,
+    onTableClosed: options?.onTableClosed
+  };
+}
+function createTablesPlugin(options) {
+  const config = resolveConfig(options);
+  const provider = options?.dataProvider ?? createMockTablesProvider();
+  const store = createTablesStore(provider);
+  const PageComponent = () => React__default.default.createElement(
+    React__default.default.Suspense,
+    { fallback: null },
+    React__default.default.createElement(TablesPage, { config, provider, store, registries: tablesRegistries })
+  );
+  return {
+    id: "tables",
+    name: config.labels.pageTitle,
+    icon: "MapPin",
+    version: "1.0.0",
+    scope: options?.scope ?? "vertical",
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: [],
+    navigation: [
+      {
+        section: options?.navSection ?? "main",
+        position: options?.navPosition ?? 4,
+        label: config.labels.pageTitle,
+        route: "/tables",
+        icon: "MapPin",
+        permission: { feature: "tables", action: "read" }
+      }
+    ],
+    routes: [
+      {
+        path: "/tables",
+        component: PageComponent,
+        permission: { feature: "tables", action: "read" }
+      }
+    ],
+    widgets: [],
+    aiTools: [
+      {
+        id: "tables.availability",
+        name: "getTableAvailability",
+        description: "Returns which tables are available, occupied, reserved, or being cleaned.",
+        icon: "MapPin",
+        mode: "read",
+        category: "Tables",
+        parameters: {
+          type: "object",
+          properties: {
+            zone: { type: "string", description: "Filter by zone name" },
+            status: { type: "string", enum: ["available", "occupied", "reserved", "cleaning"] }
+          }
+        },
+        suggestions: [
+          { label: "Which tables are available right now?" },
+          { label: "How many tables are occupied?" }
+        ]
+      },
+      {
+        id: "tables.seat-guests",
+        name: "seatGuests",
+        description: "Seats guests at a specific table.",
+        icon: "UserPlus",
+        mode: "persist",
+        category: "Tables",
+        parameters: {
+          type: "object",
+          properties: {
+            tableNumber: { type: "number", description: "Table number" },
+            guests: { type: "number", description: "Number of guests" }
+          },
+          required: ["tableNumber", "guests"]
+        },
+        permission: { feature: "tables", action: "edit" }
+      }
+    ],
+    registries: tablesRegistries,
+    settings: [
+      {
+        id: "tables",
+        label: config.labels.pageTitle,
+        icon: "MapPin",
+        component: (() => {
+          const TablesSettingsTab = () => React__default.default.createElement(saas.PluginSettingsPanel, {
+            title: "Tables Settings",
+            subtitle: "Zones and floor plan configuration",
+            registries: tablesRegistries,
+            routeBase: "/settings/tables"
+          });
+          TablesSettingsTab.displayName = "TablesSettingsTab";
+          return TablesSettingsTab;
+        })(),
+        order: 21,
+        permission: { feature: "tables", action: "read" }
+      }
+    ],
+    locales: tablesLocales
+  };
+}
+
+exports.createFayzTablesProvider = createFayzTablesProvider;
+exports.createTablesPlugin = createTablesPlugin;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map